Normalize the expression-position shape-detectors (#51)

Reading each expression detector myself (the audit agent's output was
malformed): five matched a construct on the raw r.body, so an equivalent
factoring slips them. Route them through expandAlts, same pattern as
detectTernary/detectCallExpression:

- detectBareArrowParam — `ref '=>'`; an opt-tail arrow (`[x, opt('=>', body)]`)
  was dropped (verified: variable.parameter now emitted for that factoring).
- detectPropertyAccess — `'.'`/`'?.'` before a token ref.
- detectParenArrowParams + detectArrowParamDelims — the deliberate pair that
  read the same arrow param-list production; routed identically so they still
  cannot disagree.
- detectDirectParamKeywords — keyword directly before `(`; also recurse `sep`.

detectConstructorKeywords already expands (no change). Byte-identical on all six
shipped grammars. Twelve detectors are now shape-robust. The YAML region
detectors are deferred to a semantics-aware pass: their fixed shapes encode
DELIBERATE YAML semantics (detectFold stops at a leaf token and does NOT follow
a rule-ref by design — an Indent+rule-ref is a SIBLING node, not a fold), so the
audit's heuristic "follow the ref" fix would break the fold-vs-sibling meaning.
Not every fixed shape is fragility — some are intent.

Author: johnsoncodehk

src/gen-tm.ts

@@ -2049,10 +2049,10 @@ function detectPropertyAccess(
   }
 
   function walk(expr: RuleExpr): void {
-    if (expr.type === 'seq') { checkSeq(expr.items); expr.items.forEach(walk); }
-    if (expr.type === 'alt') expr.items.forEach(walk);
-    if (expr.type === 'quantifier' || expr.type === 'group') walk(expr.body);
-    if (expr.type === 'sep') walk(expr.element);
+    for (const items of expandAlts(expr)) checkSeq(items);   // normalized factorings
+    if (expr.type === 'seq' || expr.type === 'alt') expr.items.forEach(walk);
+    else if (expr.type === 'quantifier' || expr.type === 'group') walk(expr.body);
+    else if (expr.type === 'sep') walk(expr.element);
   }
 
   for (const rule of grammar.rules) walk(rule.body);
@@ -2079,8 +2079,8 @@ function detectBareArrowParam(grammar: CstGrammar, tokenNames: Set<string>): boo
   }
 
   function walk(expr: RuleExpr): boolean {
-    if (expr.type === 'seq') return checkSeq(expr.items) || expr.items.some(walk);
-    if (expr.type === 'alt') return expr.items.some(walk);
+    if (expandAlts(expr).some(checkSeq)) return true;   // normalized factorings (opt-tail / alt / group)
+    if (expr.type === 'seq' || expr.type === 'alt') return expr.items.some(walk);
     if (expr.type === 'quantifier' || expr.type === 'group') return walk(expr.body);
     if (expr.type === 'sep') return walk(expr.element);
     return false;
@@ -2112,8 +2112,8 @@ function detectParenArrowParams(grammar: CstGrammar): boolean {
   }
 
   function walk(expr: RuleExpr): boolean {
-    if (expr.type === 'seq') return checkSeq(expr.items) || expr.items.some(walk);
-    if (expr.type === 'alt') return expr.items.some(walk);
+    if (expandAlts(expr).some(checkSeq)) return true;   // normalized factorings (opt-tail / alt / group)
+    if (expr.type === 'seq' || expr.type === 'alt') return expr.items.some(walk);
     if (expr.type === 'quantifier' || expr.type === 'group') return walk(expr.body);
     if (expr.type === 'sep') return walk(expr.element);
     return false;
@@ -2159,8 +2159,8 @@ function detectArrowParamDelims(grammar: CstGrammar): { open: string; close: str
     return false;
   }
   function walk(expr: RuleExpr): boolean {
-    if (expr.type === 'seq') return checkSeq(expr.items) || expr.items.some(walk);
-    if (expr.type === 'alt') return expr.items.some(walk);
+    if (expandAlts(expr).some(checkSeq)) return true;   // normalized factorings (opt-tail / alt / group)
+    if (expr.type === 'seq' || expr.type === 'alt') return expr.items.some(walk);
     if (expr.type === 'quantifier' || expr.type === 'group') return walk(expr.body);
     if (expr.type === 'sep') return walk(expr.element);
     return false;
@@ -2289,9 +2289,10 @@ function detectDirectParamKeywords(
   }
 
   function walk(expr: RuleExpr): void {
-    if (expr.type === 'seq') { checkSeq(expr.items); expr.items.forEach(walk); }
-    if (expr.type === 'alt') expr.items.forEach(walk);
-    if (expr.type === 'quantifier' || expr.type === 'group') walk(expr.body);
+    for (const items of expandAlts(expr)) checkSeq(items);   // normalized factorings
+    if (expr.type === 'seq' || expr.type === 'alt') expr.items.forEach(walk);
+    else if (expr.type === 'quantifier' || expr.type === 'group') walk(expr.body);
+    else if (expr.type === 'sep') walk(expr.element);
   }
 
   for (const rule of grammar.rules) walk(rule.body);