[compiler] Fix for uncalled functions that are known-mutable

[josephsavona]

Stack from ghstack (oldest at bottom):

• [compiler] Validate against mutable functions being frozen #33079
• -> [compiler] Fix for uncalled functions that are known-mutable #33078
• [compiler] Add types for WeakMap, WeakSet, and reanimated shared values #33077

If a function captures a mutable value but never gets called, we don't infer a mutable range for that function. This means that we also don't alias the function with its mutable captures.

This case is tricky, because we don't generally know for sure what is a mutation and what may just be a normal function call. For example:

hook useFoo() {
  const x = makeObject();
  return () => {
    return readObject(x); // could be a mutation!
  }
}

If we pessimistically assume that all such cases are mutations, we'd have to group lots of memo scopes together unnecessarily. However, if there is definitely a mutation:

hook useFoo(createEntryForKey) {
  const cache = new WeakMap();
  return (key) => {
    let entry = cache.get(key);
    if (entry == null) {
      entry = createEntryForKey(key);
      cache.set(key, entry); // known mutation!
    }
    return entry;
  }
}

Then we have to ensure that the function and its mutable captures alias together and end up in the same scope. However, aliasing together isn't enough if the function and operands all have empty mutable ranges (end = start + 1).

This pass finds function expressions and object methods that have an empty mutable range and known-mutable operands which also don't have a mutable range, and ensures that the function and those operands are aliased together and that their ranges are updated to end after the function expression. This is sufficient to ensure that a reactive scope is created for the alias set.

NOTE: The alternative is to reject these cases. However, even if we do that we likely won't be able to flip the validation on immediately, so I think it still makes sense to have the compiler do the more-correct thing in the invalid case. Especially considering that there are examples, like with pure caching, that technically violate the rules but are pure in practice.