[compiler] Transitively hoist function declarations referenced from hoisted callers

[tejasupmanyu]

Summary

BuildHIR hoists a function declaration F when F is referenced before its lexical position in a block, but the analysis is shallow: it doesn't walk F's body to find other function declarations in the same block that F calls. The codegen lowers a non-hoisted function declaration that's captured by memoization into a const foo = ... binding initialized at the original lexical position. When F runs ahead of a callee's lexical position (because F itself was hoisted, or invoked from one), the callee's const is still in the TDZ and the call throws ReferenceError: Cannot access 'X' before initialization.

Repro from the linked issue (smaller form):

function Component({data}) {
  const result = compute(data);     // compute hoists as a function decl
  function helper(x) { return x > 0; }
  function compute(arr) {
    return arr.filter(helper);      // helper is in TDZ here
  }
  return <div>{result.length}</div>;
}

Compiled output before this change (TDZ at runtime):

result = compute(data);
let t1;
if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
  t1 = function helper(x) { return x > 0; };
  $[2] = t1;
} else { t1 = $[2]; }
const helper = t1;                  // ← TDZ when compute(data) calls helper
function compute(arr) { return arr.filter(helper); }

Compiled output with this change (both hoist as function declarations):

result = compute(data);
function helper(x) { return x > 0; }
function compute(arr) { return arr.filter(helper); }

Reported on multiple real projects, including Comcast/react-data-grid.

Fixes #33689

Fix

After the per-statement hoist analysis populates willHoist, walk the body of each hoisted function declaration and add references to other hoistable function declarations from the same block scope. Iterate to a fixpoint so chains (a → b → c) and mutually recursive groups are handled.

Cases unaffected: when the call site appears after the declarations, nothing is added to willHoist, and the existing memoization output is preserved.

Test plan

• Added transitive-hoist-function-declaration.js regression fixture. Eval output <div>{"result":[1,2]}</div> confirms the compiled function runs end-to-end without TDZ.
• Manually verified the variants from the issue (mutual recursion a ↔ b; chain a → b → c; call placed after declarations — no over-hoisting).
• Full snap suite: 1720/1720 pass on this branch.
• yarn workspace babel-plugin-react-compiler lint clean.
• Pre-existing error.todo-functiondecl-hoisting and error.todo-valid-functiondecl-hoisting fixtures still pass (their expected errors are unchanged — the fix only expands willHoist, doesn't change downstream pruning).