…ring

Follow-up to the emphasis rewrite, from code review.

A run that closes one pair and then opens the next spends characters from
opposite ends, so a single "how many are left" counter is not enough: it
handed the same character to both pairings. `*foo***bar*` emitted the
second span one character early, and `**foo***bar**` emitted two
overlapping spans, which cost the tokenizer the whole `<em>bar</em>`.
Track the run's unspent window as `[left, right)` instead — the closer
advances `left`, the opener retreats `right`.

Three more problems, all of them the scan not agreeing with the
tokenizer:

  - `backlash` matches `\(`, so trying it before the math rules made the
    `case '\\'` branch unreachable and left the `*` inside `\(x*y\)` a
    delimiter. Order the scan like `INLINE_HANDLERS` does.
  - Each nesting level re-scanned its own content, which judged the
    content's edge runs against the string boundary rather than the
    markers now around them: `*_b.__*` grew an inner `<em>` the enclosing
    scan had deliberately refused. Key the spans by absolute position and
    hand the same map down to the children instead.
  - `lowerPriority` ran per level over the whole span, turning a
    keystroke on deeply nested emphasis into seconds of work
    (`'*'*2000 + a + '*'*2000`: 34 ms before the rewrite, 4.6 s after).
    It is redundant now that the scan steps over what binds more tightly,
    so drop it and complete that set instead: reference links and images
    whose label resolves, extended autolinks, and the tighter-binding
    check `tryLink` applies. The same input now tokenizes in 4.3 ms.

`~~` is deliberately not in that set: GFM strikethrough is a delimiter
run of its own, so `*a ~~b*c~~ d*` is `<em>a ~~b</em>c~~ d*`, as
cmark-gfm has it.

Over every line of the CommonMark corpus this changes three results
against the previous commit, all of them towards the spec — CM 0.31 #523
`*foo [bar* baz]` now yields `<em>foo [bar</em> baz]`.

Adds a seeded property test for the invariant the spec examples do not
pin down: no two spans may partially overlap, and a span's markers must
match.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

The delimiter scan has to know where a link, image, reference, autolink or
math span starts and ends, so it can step over the `*` and `_` inside one.
It answered that with its own copy of each handler's acceptance gate, and
two of the copies were already wrong:

  - a reference link was taken as inert without `tryReferenceLink`'s
    `lowerPriority` check, so a code span overrunning the brackets hid
    delimiters the tokenizer would go on to treat as real;
  - an extended autolink was taken as inert everywhere, though
    `tryAutoLinkExtension` only ever makes one at the top level — inside a
    `~~…~~` the scan skipped a bare URL the tokenizer renders as plain
    text, losing the emphasis in `~~www.x.com/a*b*c~~`.

Lift the three gates into `utils.ts` — `matchBracketed`, `matchReference`,
`matchExtendedAutoLink`, over a shared sticky `matchAt` so they can answer
at an index as well as at the head of a string — and call them from both
sides. `tryImage`, `tryLink`, `tryReferenceLink`, `tryReferenceImage` and
`tryAutoLinkExtension` shrink to one call each. `BACKSLASH_MATH_RULES`
moves to `rules.ts` for the same reason.

`collectRuns` walks the whole inline string, and three of its per-character
tests were regexps where a comparison does. On a 2000-character prose
paragraph the scan spent most of its time deciding that ordinary letters
start nothing:

  - the alphanumeric test before an extended autolink ran `.test()` on a
    freshly materialized one-character string, once per character;
  - an extended autolink was then attempted at every word start, 351 times,
    though its pattern needs `www.`, `http` or `@` somewhere;
  - the boundary test before it was a second regexp on another one-char
    string.

Character codes for the first and third, and one `includes` pass per scan
for the second. The scan drops from 0.047 ms to 0.005 ms, ~6% off a
keystroke's tokenize — this runs on the focused paragraph on every key.

Also names the two things the pairing loop kept spelling out: `unspent(run)`
for the `[left, right)` window the `IDelimiterRun` comment describes, and
`canPair` for the opener search, whose `break` used to mean "found" five
lines from a `break` meaning "not found".

…ated

Three places still describe the world before `emphasis.ts`:

  - `INLINE_HANDLERS` claims its array order "IS the rule-precedence
    contract". True for every handler but `tryStrongEm`, which sits third
    and defers to constructs handled further down the list.
  - `validateRules` was the "binds tighter than emphasis" set; emphasis no
    longer consults it and its only remaining caller is the emoji guard.
    Renamed `emojiValidateRules`, with a note that its membership is
    inherited from that era and is wider than an emoji guard needs.
  - `tokenizerFac`'s `emphasisSpans` parameter is defaulted, so the four
    recursions that must NOT inherit the parent's map say so only by
    omission — and they are correct for two opposite reasons. Written down
    at the parameter, because getting it wrong yields a mis-ranged token
    rather than a type error.

…ches

The suite's token-tree renderer carried a local `escapeHtml` that the
public `escapeHTML` already covers (the only difference, `'` → `'`,
appears in none of the 132 emphasis examples), plus cases for `image`,
`html_escape` and `hard_line_break` that no input in the file can reach.

Removes the 154 comment lines this branch added across the emphasis
scanner, the lexer, the rules and the two new specs, keeping only the
functional directives (eslint-disable, @vitest-environment,
@ts-expect-error) and the pre-existing comments that merely moved file or
had to be reworded because the symbol they named is gone.