Summary

Refactors the InnerGraph tree-shaking utility so purity can be tracked across module boundaries, not just
within a single module.

What kind of change does this PR introduce?

TL;DR

A /*#__NO_SIDE_EFFECTS__*/ annotation in one module is now honored by call sites in other modules — not
just within the file it was declared in.
Example

// pure.js
/*#__NO_SIDE_EFFECTS__*/
export function pureFn(x) { return x; }

// index.js
import { pureFn } from "./pure";

const r = pureFn(1);   // result never read

Before this PR, pureFn shows up in usedExports because the /*#__NO_SIDE_EFFECTS__*/ hint stayed inside
pure.js and never reached the importer, so the call site pureFn(1) was treated as a usage with sideEffects.
After this PR, pureFn export can be tree-shaken.

How the optimization works:

1. Producer records purity locally. While parsing pure.js, the parser sees the
   /*#__NO_SIDE_EFFECTS__*/ and writes the name into
   module.buildInfo.pureFunctions. At this point the purity is just a per-module fact.

2. Purity is lifted onto the export descriptor. When HarmonyExportSpecifierDependency / HarmonyExportExpressionDependency build their ExportsSpec, they consult
   buildInfo.pureFunctions and emit { name: "pureFn", isPure: true }. This is the
   only channel that crosses the module boundary.

3. FlagDependencyExportsPlugin propagates isPure to ExportInfo and the
   new isPure flag is copied onto the matching ExportInfo.

4. Importer tags the local binding with a deferred pure predicate. When index.js is parsed, the inner graph
   creates a TopLevelSymbol for the imported pureFn and its pure field is a function for purpose of deferring instead of definite true. The deferral matters because the importing module may not yet be parsed.

5. Per-compilation state. Inner-graph state is now scoped to the Compilation
   (getInnerGraph(compilation)) and keyed by Module, which is what lets step 4 reach into another module's
   ExportsInfo from inside the importer's graph.

6. Inference resolves the call. When inferDependencyUsage walks the importer's graph, it reaches the
   pureFn(1) call, asks the symbol isPure(compilation, module), gets true, so propagate pure-symbol usage through the inner graph.

Did you add tests for your changes?

Yes

Does this PR introduce a breaking change?

No

If relevant, what needs to be documented once your changes are merged or what have you already documented?

No

Use of AI

Partial