YAML detectors: one safe positional fix, three confirmed deliberate (#51)

Worked the YAML region detectors semantics-aware (not the audit's heuristic).
Key finding: the audit's "route through expandAlts" fix is WRONG for these —
they match STRUCTURAL nodes (a `(Newline item)*` quantifier, config-keyed
bracket pairs), and expandAlts EXPANDS the very quantifier they depend on.

- detectBlockSequence — the one genuine positional rigidity: it matched the
  `[item, (Newline item)*]` pattern only at items[0]/items[1]. Now scanned
  pairwise (any adjacent k), so a leading element before the sequence does not
  hide it. NOT routed through expandAlts (that would expand the quantifier).
  yaml byte-identical; the full yaml gate group (depth-witnesses, deepest-sibling,
  compact-nest-sites, flow-sites, blockscalar-depth, issue12) stays green.
- detectFold — its visit is ALREADY pairwise; its refsLeaf stopping at a leaf
  token (not following a rule-ref) is the DELIBERATE fold-vs-sibling distinction
  (an Indent+rule-ref is a sibling node). No change.
- detectExplicitKey — the indicator at items[0] is intrinsic (an explicit-key
  entry is headed by `?`); the inner already unwraps a quantifier. No change.
- detectFlowCollections — topLits is positional-agnostic and unwraps
  quantifier/group/sep, deliberately stopping at alt/ref to read THIS rule's own
  structure. No change.

So the fixed-window fragility class is closed: 13 detectors made shape-robust
where the rigidity was accidental; the rest is deliberate YAML semantics that
the heuristic over-flagged. Not every fixed shape is fragility.

Author: johnsoncodehk

src/gen-tm.ts

@@ -3626,10 +3626,13 @@ function detectBlockSequence(grammar: CstGrammar): { indicator: string } | null
   let indicator: string | null = null;
   const visit = (e: RuleExpr): void => {
     if (e.type === 'seq') {
-      // `[item, (Newline item)*]`: first element + a `*`/`+` over a `[Newline, item]` seq
-      if (e.items.length >= 2) {
-        const head = e.items[0];
-        const q = e.items[1];
+      // `[…, item, (Newline item)*, …]`: an item ADJACENT to a `*`/`+` over a `[Newline, item]` seq.
+      // Scanned pairwise (any k, not only items[0]/items[1]) so a leading element before the
+      // sequence pattern does not hide it. NOT routed through expandAlts on purpose — that would
+      // expand the `(Newline item)*` quantifier this match depends on.
+      for (let k = 0; k + 1 < e.items.length; k++) {
+        const head = e.items[k];
+        const q = e.items[k + 1];
         if (q.type === 'quantifier' && (q.kind === '*' || q.kind === '+') && q.body.type === 'seq'
           && q.body.items.length >= 2 && q.body.items[0].type === 'ref' && q.body.items[0].name === newlineToken) {
           const ind = itemIndicator(head);