Add a spec-mapped reference (CSS Syntax Level 3 §4) above `_charClass`
explaining why the per-character dispatch table is used and listing which
code points map to each handler class, so future spec changes are easy to
locate and apply.

`_consumeAnIdentSequence` runs per code point of every ident, at-keyword,
hash, function name and unit — the hottest tokenizer function on a large
real-world build (Tailwind v4). Inline the two per-char checks: the ASCII
ident test becomes a direct table load (no `_isIdentCodePoint` call), and
the terminating escape test reads the next code point only when the char
is a backslash instead of eagerly via `_ifTwoCodePointsAreValidEscape`.

~1.7% faster on lex-only over the Tailwind build; token output unchanged.

Annotate the `consumeAToken` char-class switch so each case states which
CSS Syntax §4 token(s) it yields (and why `-`/`+`/`.`/`#`/`@`/`<`/`\\` branch
further), making the optimized dispatch self-documenting.

consumeAComponentValue is called for every component value (the bulk of
nodes on a large stylesheet). Two redundancies removed:

- It re-called ts.next() even though every caller had already peeked that
  token; thread the peeked token in (default ts.next() for the few callers
  that don't) so the common loops skip the extra call.
- The leaf-token branch delegated to consumeATokenAsNode, which peeked the
  token a third time via ts.consume(); inline it (advance + tokenToNode on
  the token we already hold).

~2% faster on a Tailwind v4 build (CPU-isolated); token/AST output
unchanged.

tokenToNode was a ~20-arm switch with a `new Token(...)` in each arm. V8
compiled those into generic construct stubs (visible in profiles), since
the function had many allocation sites. Replace the switch with a
lexer-type → node-type lookup table and one `new Token` call (URL, the
only leaf with own state, handled separately).

~13% faster on a CPU-isolated parse, ~6% on a Tailwind v4 build; AST
output unchanged.

Introduce an accessor object A in lib/css/syntax.js routing every AST-node
field read through a function, so the node representation can be swapped from
class objects to a struct-of-arrays without touching consumers. Additive and
object-backed for now; no behavior change.

Rewrite every AST-node field read in CssParser to go through the A accessor
object instead of touching node properties directly, and move the ad-hoc
`urlRecovery` flag off the node into a parser-local. Behavior-preserving
(654 css config cases pass); prepares the consumer for a struct-of-arrays
node representation.

Build every parser node through module-level construction primitives
(_mkLeaf / _mkContainer / _setName / ...) instead of calling new Token /
new Container directly. An object backend reproduces the existing
class-instance tree the parseA* entry points return. This is a
behavior-preserving refactor (654 css config cases + 105 parser unit tests
pass) that lets the streaming grammar swap in a struct-of-arrays backend
without forking the consume algorithms.

The streaming grammar (the only path CssParser uses) now builds nodes into
reused typed arrays instead of class instances: node fields live in parallel
Uint8/Int32 arrays indexed by a 1-based node id, child lists hang off three
object arrays, and the write cursor is reset after each top-level rule's walk
so the buffers are reused and the parse allocates almost nothing across rules.
The A accessor reads the arrays, so CssParser is unchanged. parseA* keep the
object backend (retainable class tree the unit tests inspect).

654 css config cases + 105 css parser unit tests pass.

Remove the dead isIdentStartCodePoint (superseded by _isIdentStartCodePointCC)
and the unused HC_DELIM constant (the delim class is the default 0), brace the
char-class build loop, and order the parser unit-test imports — clearing the
eslint debt on the touched files.

The typed-array buffers stay pooled across parses for reuse, but the
per-container child-list arrays are dropped once the parse completes so they
are not retained idle until the next parse overwrites them (matters for watch
builds between rebuilds).

This reverts commit e3c112a.

The Ident and Declaration value-visitors sliced the node value / property
name on every node even for plain (non-CSS-Modules) stylesheets, where the
dashed-ident and ICSS paths that consume them are inert. Gate that work behind
the dashed/ICSS context (Ident) and isModules (Declaration), so the common
non-modules parse skips a slice per ident and a slice + property-name
normalization per declaration. ~6.5% faster on a non-modules Tailwind parse;
CSS Modules behavior and output unchanged (654 css config cases pass).

processDashedIdentInVarFunction fires for every var()/style() in CSS-Modules
mode (Tailwind has thousands). It sliced the first ident's value only to test
the `--` prefix; check the two leading bytes directly instead. CSS Modules
output unchanged (654 css config cases pass).