…pure chains (#10432)

Follow-up to #10427.

#10427 restored the eagerly-evaluated child effects of manual-pure chains, but its eager-child walk maps *every* spread argument to an unknown side effect. So a manual-pure chain wrapping a statically-safe spread — `make(...[]).value`, `make(...'').value`, `make(...[])()` — is now retained wholesale, even though spreading an array, string, or template literal only runs built-in iterators. Rollup drops these.

## Fix

Surface spread arguments distinctly from plain eager children (new `EagerChild` enum) and analyze them with `analyze_spread_argument`, mirroring oxc's `Argument::may_have_side_effects`:

- array / string / template-literal operands are analyzed through the (oxc-gated) expression analyzer, so a side-effectful element (`make(...[effect()])`) or a nested spread (`make(...[...x])`) still retains the statement;
- any other operand stays conservatively unknown, since evaluating or iterating it may run a user-defined `Symbol.iterator`.

## Tests

New unit test `test_manual_pure_chains_drop_side_effect_free_spreads` covers both directions: safe literal spreads become removable, while effectful or opaque spreads stay retained — including the nested-spread (`...[...x]`) and bare-identifier (`...x`) cases that must not under-retain.

…rix to unit tests

The `manual-pure-functions` fixture (from #10427) re-tested the retain/remove
matrix that the `stmt_eval_analyzer` unit tests already own. A JS fixture only
needs to smoke-test that the `manualPureFunctions` option is wired through the
pipeline; the behavioral matrix belongs in fast, precise Rust unit tests.

- Trim `main.js` to two statements: one manual-pure call dropped (no
  side-effectful children) and one retained because an argument has a side
  effect — the latter also exercises the one pipeline behavior a unit test can't
  see, the `import styled from "styled-components"` binding staying alive.
- Add `test_manual_pure_chains_without_eager_children_are_side_effect_free`,
  covering the removed shapes (make.div, make.div`x`, make?.div(), make()(),
  make().div()) that previously had end-to-end-only coverage.

Test-only; no behavior change.

…rix to unit tests

The `manual-pure-functions` fixture (from #10427) re-tested the retain/remove
matrix that the `stmt_eval_analyzer` unit tests already own. A JS fixture only
needs to smoke-test that the `manualPureFunctions` option is wired through the
pipeline; the behavioral matrix belongs in fast, precise Rust unit tests.

- Reduce `main.js` to a single smoke case: a listed function's call
  (`styled.div`...``) is dropped, leaving just `import "styled-components";`.
- Add `test_manual_pure_chains_without_eager_children_are_side_effect_free`,
  covering the removed shapes (make.div, make.div`x`, make?.div(), make()(),
  make().div()) that previously had end-to-end-only coverage. The retained-child
  and spread matrices were already unit-tested.

Test-only; no behavior change.

…rix to unit tests

The `manual-pure-functions` fixture (from #10427) re-tested the retain/remove
matrix that the `stmt_eval_analyzer` unit tests already own. A JS fixture only
needs to smoke-test that the `manualPureFunctions` option is wired through the
pipeline; the behavioral matrix belongs in fast, precise Rust unit tests.

- Reduce `main.js` to a single smoke case: a listed function's call
  (`styled.div`...``) is dropped, leaving just `import "styled-components";`.
- Add `test_manual_pure_chains_without_eager_children_are_side_effect_free`,
  covering every removed shape the fixture used to own end-to-end — bare call,
  member read, tagged template, and optional/repeated/chained calls — plus a
  scoping check that an unlisted call keeps its side effects. The retained-child
  and spread matrices were already unit-tested.

Test-only; no behavior change.

…rix to unit tests

The `manual-pure-functions` fixture (from #10427) re-tested the retain/remove
matrix that the `stmt_eval_analyzer` unit tests already own. A JS fixture only
needs to smoke-test that the `manualPureFunctions` option is wired through the
pipeline; the behavioral matrix belongs in fast, precise Rust unit tests.

- Reduce `main.js` to a single smoke case: a listed function's call
  (`styled.div`...``) is dropped, leaving just `import "styled-components";`.
- Add `test_manual_pure_chains_without_eager_children_are_side_effect_free`,
  covering every removed shape the fixture used to own end-to-end — bare call,
  member read, tagged template, and optional/repeated/chained calls — plus a
  scoping check that an unlisted call keeps its side effects. The retained-child
  and spread matrices were already unit-tested.

Test-only; no behavior change.

…move matrix to unit tests (#10436)

Follow-up to #10427 / #10432 (both merged).

There's exactly one JS-side `manualPureFunctions` test — the `manual-pure-functions` fixture (added in #10427). It re-tested the retain/remove behavior matrix that the Rust `stmt_eval_analyzer` unit tests already own. A JS fixture only needs to smoke-test that the option is wired through the pipeline; the exhaustive behavior belongs in fast, precise Rust unit tests.

## Changes

- **Fixture → minimal smoke test.** `main.js` is now a single case: a listed function's call (`` styled.div`...` ``) is dropped, leaving just `import "styled-components";`. That alone proves the `manualPureFunctions` option reaches the pipeline — without it, the call would be retained. Snapshot regenerated against a fresh debug build.
- **Rust unit test.** `test_manual_pure_chains_without_eager_children_are_side_effect_free` covers the removed shapes (`make.div`, `` make.div`x` ``, `make?.div()`, `make()()`, `make().div()`) that previously had end-to-end-only coverage. The retained-child and spread matrices were already unit-tested (`test_manual_pure_chains_keep_eager_child_side_effects`, `test_manual_pure_chains_drop_side_effect_free_spreads`).

Test-only; no behavior change.