perf(css): recycle nested block contents during the walk - #21628

`_streamConsumeBlock` recurses through the block consumer, so its own locals
already are the stack — the four parallel arrays it pushed and popped per
rule were eight array operations, with their bounds and capacity checks, on
every rule. It cost 5.2% self time in a CPU profile of a flat stylesheet,
where streaming reclaims nothing and the work is pure overhead.

Save the frame into locals across the recursive call instead. Interleaved
A/B, min of 35 samples per side, 20k rules: flat +9.3% -> +1.8%, many small
blocks +17.2% -> +10.6%, one big `@media` -23.9% -> -2.7%, `@supports`
+3.0% -> -1.7%, nested at-rules -5.2% -> -3.3%, CSS nesting +0.8% -> -0.6%.

Memory is unchanged: every shape that held a subtree still recycles to zero.
The remaining cost on small blocks is the streaming machinery running where
there is nothing to reclaim, which the lazy activation threshold addresses.

The streamed walk ran on every block, so a small one paid the machinery for
nothing: +9.3% on a flat stylesheet, +17.2% on many small `@media`.

Enter a rule and start recycling only once its block passes
`_STREAM_MIN_NODES`. `_nodeCount` restarts at each top-level node, so
`_nodeCount - mark` is exactly how far the current block has grown; under
the threshold the sink collects like the non-streaming path and the rule is
handed back materialized for the ordinary walk, keeping `A.declarations` /
`A.childRules` readable on it.

Activation has to enter every still-buffering ancestor first, outermost in,
or a nested block enters before its parent — `@media{@supports{...}}` fired
the inner rule's `enter` first. Ancestors are unreachable from locals, so
the per-block frame moved into depth-indexed tables: nesting is shallow and
strictly LIFO, so an indexed store avoids the bounds and capacity checks
that push/pop cost on every rule.

Memory is now released on every shape that used to hold a subtree: one big
`@media`, `@supports`, nested at-rules and CSS nesting all go from
8.05 / 4.39 MiB to 0. CPU is +1.8% to +7.7% — the sink still costs an
indirect call per child before activation, which the next commit removes by
checking the threshold inside the block consumer instead.

A block wrote its frame and pushed every child through the sink from the
moment it opened, so a stylesheet with no big block paid for machinery it
never used. Keep the block's state in `consumeABlocksContentsInto`'s locals
and write the frame only where an ancestor could still be reached for --
just before a child rule, and on the block's own growth past the threshold.
A block of nothing but declarations, which is every leaf rule, now touches
no frame at all, and the growth check is one compare in the collect loop
rather than a call and a type test per child.

Two fixes fall out of entering a rule before its block is consumed:

- Sibling indices were wrong on every streamed block: the parent's counter
  was bumped when a child block opened and then reused as the walk counter,
  so the first child of a large `@media` reported index 456. Each list now
  counts separately, as `_walkRule` does, and the index a child carries is
  the one the collected walk gives it.
- `A.declarations` / `A.childRules` returned `null` on a streamed rule --
  indistinguishable from an at-rule with no block, which is what
  `CssParser` reads to decide. The body slot is claimed, empty, before
  `enter` fires; claiming it up front also lets the slots be handed back
  per child, which is the last thing a streamed block still grew.

Threshold raised to 16384 nodes: a block that crosses it just before its
own `}` activates for almost nothing back.

Measured against main, 20k rules per shape, each arm in its own process,
median of 13: @media -9.6%, @supports -8.0%, @media>@supports -11.4%, CSS
nesting -7.5%, flat +0.2%, many small @media +1.0%. Retained heap while the
block is open, forced GC: 31.2 MiB of node columns and 3.9 MiB of JS heap
down to 0 and 0.16 MiB. The default path is unchanged.

`streamBlocks` was walk-only, because the printer builds a parent's text
out of its children's -- exactly what a streamed body has already released.
So printing held the whole subtree: 60 MiB live while a 20k-rule `@media`
was open, for 3.2 MiB of output.

A streamed rule now prints as it goes: its `prelude{` is held back when the
block opens, each finished child is emitted straight after it, and the `}`
closes it. Held rather than emitted, because an opener that turns out to
have nothing inside it still has to be droppable at its `}` -- a whole
stack of them, since the block that empties may be several levels down.

Two transforms genuinely need a whole block at once, and neither is given
up:

- A longhand family only merges in a block with no child rule, so a block
  of declarations alone is the one that declines to stream.
- Only the last of a set of identical declarations can be read. There is no
  looking ahead for the later one, so the earlier one is taken back out of
  the output instead: `PrintContext` keeps the output as the pieces it was
  emitted in, and a piece can be retracted after later ones are out.

Positions follow from that -- a piece's place in the output is no longer
known when it is emitted, so mappings anchor to a piece and are resolved
against the pieces once, when a map is asked for. Printing without one now
never scans the text for newlines at all.

Output is byte for byte the collected printer's, source map included, over
23 shapes covering empty blocks, duplicate declarations across a child
rule, kept comments, raw hacks, custom properties and `@keyframes`.

Minifying 20k rules, each arm in its own process, median of 11: `@media`
-36.8%, `@media>@supports` -38.1%, CSS nesting -36.9%, flat +0.4%, many
small `@media` +2.0%. Retained heap while the block is open: 60.4 -> 7.7
MiB on `@media`, 16.3 -> 3.8 MiB on nesting, against 3.2 and 0.7 MiB of
output. The collected path is unchanged, on both CSS and HTML.

…here needed

Two regressions on stylesheets that never stream, both from how the output
is now held.

Every emit became a piece of its own, so a flat stylesheet -- the common
one -- built an array of 20k strings where it used to append to one. Output
accumulates into a plain string again, and a piece is cut off only for text
that may still be taken back, which is the block's own declarations and
nothing else. Mappings carry an offset within their piece, so an anchor can
sit mid-string.

The other was subtler and was costing 3.8 MiB. A printer returns its text
as a rope of its children's pieces, and the old `_emit` happened to flatten
each one while scanning it for newlines -- a scan this branch had removed as
useless, since positions are now worked out only if a map is asked for.
Without it, ropes append onto ropes and every fragment of every node stays
reachable until the output is finally flattened: a second copy of the whole
output. Flattening each piece as it lands fixes the memory and costs 40% CPU,
an allocation per piece. So the tail is cut off and forced flat once per 64
KiB instead, which the result would have copied anyway.

Measured against main, each arm in its own process, arms alternated:

  minify, retained heap while the block is open, 20k rules
    @media      60.4 -> 3.4 MiB    flat   5.9 -> 5.0 MiB
    nesting     16.3 -> 1.2 MiB    small @media  3.9 -> 3.9 MiB
  minify CPU, 10k rules, median of 9
    @media -35.3%   @supports -31.9%   nesting -29.2%
    flat +2.2%   small @media +3.3%   (both inside the +/-5% this box resolves)

Output and source map stay byte for byte main's, streamed or not.

`streamBlocks` was an opt-in because streaming used to be walk-only, and a
caller that printed had to decline it. Printing streams too now, so there is
nothing left for the option to trade off: a block under the threshold is
still collected and walked in one batch exactly as it always was, and one
past it streams. So the walk always streams and the option is gone.

It stays a flag internally, because the standalone `parseA*` entry points
hand back a materialized tree and must not stream; `_setupParse` leaves it
off for them and only `grammar` turns it on.

What a streamed rule reports about its own block is now the walk's ordinary
behaviour rather than something a caller asked for, so `A.declarations` and
`A.childRules` say so where they are defined: they read as an empty block on
a streamed rule, and `null` still means no block at all.

The tests can no longer print a stylesheet both ways to compare, so they
assert the output itself, over fixtures already in minimal form. Every case
pins whether it is exercising the streamed or the collected path, so none of
them can quietly stop testing streaming if the threshold moves.

Generated positions are worked out when a map is asked for rather than as
the output is built, by walking the output alongside the mappings. But the
walk asked `indexOf` for the next newline once per mapping, and `indexOf`
has no end bound: with no newline ahead it scans to the end of the piece and
returns -1, every time. Minified output has no newlines at all, so every one
of a piece's mappings scanned the whole piece -- quadratic in the mappings a
piece holds, which is one per top-level rule.

Carry the next newline's offset across mappings instead, and look for
another only after one is passed. A piece with no newlines is scanned once.

Minifying 10k rules, each arm in its own process, median of 9: flat +2.7%
-> -2.9%, many small `@media` +3.6% -> -5.8%.