Align `HtmlParser` with `CssParser`: rather than calling `buildHtmlAst` and
passing a pre-built `ast`, it now calls `.process(source, { skipTextData: true })`
and the AST is built inside the processor's grammar. Rename the `rawText`
option to `skipTextData` and pass it through the process options object, like
the CSS `as` option. Node structure and offsets are unchanged.

Convert the HtmlParser unit tests to drive the real parser on real HTML
instead of mocking `buildHtmlAst`.

`options.ast` only existed so the old `HtmlParser` could pass a pre-built
tree; with AST building moved inside the processor's grammar nothing supplies
it, and the CSS `SourceProcessor` has no equivalent. `fragmentContext` stays:
it is the HTML analog of the CSS `as` parse-mode option and is exercised by the
html5lib fragment conformance tests.

Generalize the text-data optimization into a `skip` set on `buildHtmlAst` /
the HTML processor: `skip.text` (drop prose text, keep only raw-text element
bodies, offset-only), `skip.comments` (drop comment nodes) and `skip.doctype`
(drop the doctype node; quirks detection is unaffected). Skips are pure output
reductions — tree construction runs unchanged, so element structure and offsets
are identical with any combination.

`HtmlParser` enables `{ text, doctype }` (it reads script/style bodies by offset
and never reads prose text or the doctype); comments stay for `webpackIgnore`.
On a text-heavy 554 KiB document this cuts parser heap ~28% and time ~44%.

Add a buildHtmlAst test asserting every skip combination yields the same element
tree across construction edge cases (foster parenting, adoption agency, foreign
content, raw-text elements, quirks).

`text` was misleading — the flag drops only prose (flow-content) text and
keeps raw-text element bodies (`<script>`/`<style>`/`<textarea>`/`<title>`/…),
so `proseText` names what it actually does. `HtmlParser` now passes
`skip: { proseText: true, doctype: true }`.

Expand the skip guard tests: foreign-content CDATA, quirks (no-doctype),
entity/whitespace routing, all four raw-text body types, button scope, and
fragment-context parsing — asserting the element tree is identical under every
skip combination, and that all raw-text bodies survive offset-only.

…Text node

Rename the misleading `proseText` to `text` (the DOM/WHATWG node type) and make
it drop *every* Text node rather than keeping raw-text element bodies. A
raw-text element's body span is instead recorded as its `contentEnd` offset, so
`HtmlParser` reads `<script>`/`<style>` content as [`tagEnd`, `contentEnd`]
without a Text node. Also rename `TEXT_CONTENT_ELEMENTS` to `RAW_TEXT_ELEMENTS`
(the spec's raw text / escapable raw text elements). Memory is unchanged (~28%);
element structure and offsets stay identical under any skip combination.

Under `skip.text` the text node is dropped, so construction only needs the
run's whitespace-ness. For plain text — no entity, NUL, CR, or pending
leading-newline swallow — the decoded value equals the raw range, so scan it
once and dispatch a canonical whitespace marker instead of slicing and entity-
decoding a string that is immediately discarded. Anything trickier falls
through to the exact path unchanged.

Cuts ~4-8% off parse time on text-heavy documents (more on markup with fewer
entities). Element structure and offsets stay byte-identical; the skip guard
tests add whitespace-entity / CR / NUL cases to lock in the fallbacks.

Void elements are inserted and immediately popped, so they never receive
children — mkEl can hand them a shared frozen empty array instead of allocating
one per element (~1200 arrays on a large document). Frozen so any accidental
append throws rather than corrupting the shared instance. ~1% less parser heap;
AST unchanged.