## Summary

Follow-up to the review nit on #9669: when a wrapped ESM module tree-shakes down to an
empty body, rolldown still emitted a no-op call to its `__esm`/`__esmMin` wrapper, e.g.

```js
function en() { return "en"; }
__esmMin((() => {}))();   // ← dead weight: empty closure, calling it does nothing
```

This PR marks such no-op init calls `@__PURE__` so the default `minify: 'dce-only'`
pass drops them (and, once the wrapper is unreferenced, the wrapper declaration and the
`__esm`/`__esmMin` runtime helper too).

**Before**
```js
var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
function en() { return "en"; }
__esmMin((() => {}))();
```
**After**
```js
function en() { return "en"; }
```

It also collapses the `require(esm)` sequence form `(init_x(), __toCommonJS(x_exports))`
→ `__toCommonJS(x_exports)` via the same mechanism.

## Approach

1. A small generate-stage pre-pass, `compute_init_is_noop`, flags wrapped (`WrapKind::Esm`)
   modules whose `__esm` closure body is provably empty — every top-level statement is a
   hoisted function declaration or a source-less export clause, so nothing lands inside the
   closure. The classification runs in parallel (`par_iter_enumerated`).
2. The finalizer sets `pure = true` on the init `CallExpression` at the three emission sites
   when the callee module is flagged; `dce-only` does the rest.

The classifier is deliberately conservative (a non-qualifying statement only ever *keeps* a
redundant init call — it never drops a needed one), and a `debug_assert!` in the finalizer
cross-checks every flagged module against the *actual* `stmts_inside_closure`, so any
misclassification fails loudly across the fixture suite. Guards exclude shimmed missing
exports (their `x = void 0` lands in the closure) and concatenated wrapper groups.

## Out of scope (kept on purpose)

The empty inlined dynamic import `Promise.resolve().then(() => Object.freeze({ __proto__: null }))`
is **not** removed — Rollup keeps it for `import('./empty.js')` of an empty module, so it's
Rollup-equivalent and stays.

## Why the detection lives in its own pass (and not elsewhere)

The flag is consumed **cross-module** — an importer marks `init_importee()` pure based on the
*importee's* status — which constrains where it can be computed.

### Not in the link stage (`cross_module_optimization.rs`)

That pass runs **before** the two inputs the decision needs even exist:

- **`is_included`** is produced by tree-shaking (`include_statements`), which runs *after*
  `cross_module_optimization`. A module that's tree-shaken away has no init to reason about.
- **`concatenated_wrapped_module_kind`** is assigned during the generate stage's
  chunk/concatenation analysis. We must restrict the optimization to standalone wrappers
  (`ConcatenateWrappedModuleKind::None`): in a concatenated group the shared `init_*` runs the
  *whole group's* closure, so one module's empty body wouldn't prove the call is a no-op. That
  isn't knowable before chunks are formed.

Folding it here would force the decision with incomplete information (pre-tree-shaking,
pre-chunking).

### Not in the finalizer (`module_finalizers/`)

`finalize_modules` runs the per-module finalizers in parallel (`par_iter_mut_enumerated`):

1. **Immutable borrow** — the finalizer holds `&LinkingMetadata` / `&LinkingMetadataVec`
   (`ScopeHoistingFinalizerContext`), read-only, so it *cannot write* the flag mid-pass.
2. **Determinism** — even if it could, an importer finalizing concurrently with its importee
   could read a not-yet-computed (default `false`) value → non-deterministic `@__PURE__`
   placement → flaky snapshots.

So the flag must be settled as a barrier *before* finalization begins.

### The fit

The pre-pass sits in the generate stage **after** tree-shaking and chunk generation (so
`is_included` and `concatenated_wrapped_module_kind` are known) but **immediately before** the
parallel `finalize_modules` (so every importer reads a settled, deterministic value).

## Testing

- Updated 5 fixture snapshots (incl. the #9651 regression); each remains runnable.
- Full `rolldown` + `esbuild` integration suites pass; the `init_is_noop` debug-assert holds
  across all ~1.6k fixtures.
- `just lint-rust` clean (clippy `--deny warnings`, fmt, `cargo check --all-features`).