perf(css): write selectors, An+B and more values in their shortest spelling - #21664

A selector list is a set: the same selectors in any order match the same
elements at the same specificity. Writing one canonical order lets equal lists
compress alike and lets two rules naming one set join, and a repeat in it
matches nothing the first already did.

The equivalence harness compares a run of selectors reaching the same block
under the same conditions as the set it is, which is the invariant joining
them into one list already rests on.

CSS Syntax 3 §4.3.10 starts a number at `+` only before a digit, or before a
`.` that itself has one. Treating every `+.` as a number made `.a+.m` print as
`.a+/**/.m`, longer than the input it came from and different again on a second
pass. A join also drops a selector the other side already names.

…spelling

`An+B` carries its own whitespace, signs and case, an index under 1 matches
nothing so a forward step starts where it does, and a step selecting exactly one
child is the child Selectors 4 §14 names. A 3D matrix whose third row and column
are the identity's is the 2D matrix of the six values it leaves, and a 2D pair of
1 leaves the z scale. A zero time keeps a unit where a zero length drops one, so
it takes the shorter of the two it can carry.

The equivalence harness reads each An+B as the sequence it selects: the engine
folds `even` / `odd` itself but hands `0n+3` back as written.

A selector function's argument is a selector like the prelude's, so the
universal a compound implies says nothing there either — `:not(*.g)` is
`:not(.g)`. A lone universal is the selector, a parted one is a combinator
away, and a namespaced one is not implied.

…ly when it is one

The first/last counterpart of each An+B pseudo-class was a table typed into the
printer; it is now read out of the selector table in the generator — the An+B
half by its grammar, the counterpart by the name the pair builds, kept only
where the table has it as a selector too.

The two selector-list helpers were one function apart, and both split every
prelude to find out there was nothing to do: 50,434 of the corpus's 55,055 hold
no comma at all, so a list is only built where one can exist. `scale` and
`rotate3d` asked whether a component was one in two different spellings; both
now use the same test, which also reads `1.0`.

Every rule with two declarations was offered to three shorthand tables, and each
built the same property index again: 48,204 Map and Set allocations across the
corpus where one reused pair does. The table scan asked for its longhands
through a closure per entry — 401,700 of them — which is now a loop. And
`_isJoinablePrelude` split every prelude into a list to walk it, where 50,434 of
the corpus's 55,055 hold one selector and need no list at all.

Counted, not timed: the output is byte-identical on all 18 fixtures, and the
wall-clock difference on this machine is inside its own run-to-run spread.

`grid-auto-flow:row dense` is the `dense` omitting its group already means. The
keyword is read out of the property table and kept only where it really is the
initial and really is one alternative of a top-level `||` group; which of those
groups falls back to it is the judgement stated in the generator, since
`aspect-ratio:auto 3/2` is a ratio with a fallback rather than the ratio alone.

A rule is also offered to the three merge tables only when two of its properties
are longhands one of them names — 6,238 of the corpus's 8,034 candidate rules
are not, which is 311,900 table-entry checks that no longer run. The union is
built in the generator out of the very arrays it emits, so it cannot drift.

`_minifyNth` read an unbounded digit run, so a `B` above
`Number.MAX_SAFE_INTEGER` made `b += a` a fixed point and the
normalization loop never exited. Guard both terms and normalize by
modulo instead of by stepping.

Also spell the two new words for cspell, keep the `PAIR_LONGHANDS`
comment with its table, assert the omittable initial keyword is still
one mdn-data states, and canonicalize a nested rule's selector list in
the equivalence harness without rewriting text inside an attribute.

Deduplicating across the seam re-read the whole accumulated selector list
once per rule joined, so a run of adjacent rules printing the same block
was quadratic: 6000 of them took 2.8s where the base took 0.10s. It
bought nothing measurable — no configCases stylesheet loses a byte
without it — so the seam concatenates and the canonical form stays where
the list is the author's own.

… them

A declaration's value is one component 92 times in 100 (38151 of 41387 on
the Tailwind fixture), and the printer materialized the whole child list
to read its length and first entry. `_valueComponents` and the four
shorthand collapses now walk the child span off the node, so the list is
built only where one is really needed — a custom property's text, a
`unicode-range`, an attribute selector. Young-generation collections for
one Tailwind minify drop from 173 to 165 under a fixed semi-space, and
the emitted bytes are unchanged.

…d guard

A stale Prettier reformatted eighteen template interpolations the branch
never touched; Prettier 3 leaves interpolations alone, so `fmt:check`
passed either way and the churn stayed in the diff.

The guard that makes a spec change fail generation now takes its tables
the way the other collectors do, so a test can drive it.