Comments now reach the visitor map via NodeType.Comment instead of a
separate process({ comment }) callback, giving one uniform interface for
every token/node. They fire during tokenization (source order among
comments) on a transient SoA node, so A.start/end/loc/source work like any
other node. No comment visitor registered means no callback and zero added
work. Behavior is unchanged; magic comments and CSS-Modules pure-mode still
read the same comments side-array.

Adds a per-parse skipLeafTypes set (buildSkipLeafSet helper) so component-value
list builders can drop leaf node types nothing reads. Non-CSS-Modules parses now
skip numeric / ident / hash / colon / delim value tokens (the Ident visitor
no-ops and the Declaration visitor returns early there), which with the existing
selector-prelude skip cuts non-modules parsing time by ~13%. CSS-Modules parses
skip nothing — ICSS :export captures arbitrary value byte ranges. Output is
byte-identical in both modes.

Collapses skipSelectorPrelude (boolean) and skipLeafTypes (Uint8Array) into a
single CssProcessOptions.skip set indexed by NodeType: leaf-type entries drop
value / function-arg leaves, the QualifiedRule entry drops selector preludes.
buildSkipLeafSet becomes buildSkipSet. Behavior and output are unchanged.

Adds unit tests proving CssProcessOptions.skip drops each leaf type from both
value and function-arg lists, that skipping a Function drops its whole subtree,
that a combined set drops all listed types, that QualifiedRule drops selector
preludes while keeping the block and url() rewrites, and that the object backend
(parseA*) ignores a prior skip.

Records the two structural (not just consumer) constraints for reuse: skipping
both Delim and Ident loses !important detection, and skipping SimpleBlock loses
the custom-property {}-value check.

Completes the reusable skip mechanism: skip[AtRule] drops an at-rule prelude
(symmetric with skip[QualifiedRule], keeping url tokens / functions so
@import url(...) still resolves), and the stray-} value-list path now honours
the skip set too, so every NodeType that can appear in a component-value list
is skippable. Tests cover each leaf type, Function and SimpleBlock subtrees,
both prelude toggles, and the object-backend reset. webpack still enables only
its lean non-modules set; the added capability is for reuse.

The flat NodeType-indexed skip set was misleading: skip[Number] dropped number
nodes but skip[QualifiedRule]/skip[AtRule] dropped a rule's *prelude*, not the
rule. Replace it with a structured CssProcessOptions.skip:
  { types?: Uint8Array, selectorPrelude?: boolean, atRulePrelude?: boolean }
so value-type drops and prelude drops read unambiguously. buildSkipSet now
builds only the types set. Behavior and output unchanged.

The SourceProcessor constructor now takes default process options (skip, as, …)
merged under each process() call's own options, so skip is configured on the
processor instance and reused across parses rather than repeated per call.
CssParser now sets as/skip on the processor and passes only the per-source
locConverter to process(). Backward-compatible: HtmlParser and per-call options
are unchanged.