Fix two more sep-omission twins of the type-param keyword drop (#51)

An adversarial gap-hunt (5 agents over the classes the structural checker
does NOT cover) found that the getTypeParamElementKeywords `sep` drop had
un-fixed siblings in the same family:

- detectTypeParamConstraintKeywords.scanConstraint omitted `sep`, so a
  type-parameter CONSTRAINT keyword reached through a `&`/`,`-separated list
  was not collected — the .tsx generic-arrow⇄JSX no-comma disambiguation lost
  its constraint signal (mis-scoping the header as a JSX tag).
- detectDeclarations.containsBlockRef omitted `sep`, so a declaration whose
  brace body is reached through a `sep` was not seen as having a body — its
  #declaration-body member-scoping region was dropped.

Both recurse into `sep.element` now, mirroring the prior fix. Byte-identical
on all six shipped grammars (latent: every shipped grammar writes constraints
as `opt('extends', Type)` and block bodies as direct refs).

The hunt found 8 latent completeness gaps total; all were VERIFIED latent —
tokenizing the witnesses against the shipped grammars shows ternary, calls,
trailing-comma type params, and every prec operator are correctly scoped, so
the 0-gap soundness ledger is real, not corpus-blind. The remaining gaps are
detector SHAPE-FRAGILITY (fixed-offset window matching in detectTernary /
detectCallExpression / isAngleBracketSepRule misses equivalent factorings),
an unimplemented `rawBlock` config region, and punctuation-in-region — tracked
for follow-up; none triggers on a shipped grammar.

Author: johnsoncodehk

src/gen-tm.ts

@@ -1109,6 +1109,10 @@ function detectTypeParamConstraintKeywords(grammar: CstGrammar, typeArgRule: str
       for (const it of (expr as { items: RuleExpr[] }).items) scanConstraint(it);
     } else if (expr.type === 'group') {
       scanConstraint((expr as { body: RuleExpr }).body);
+    } else if (expr.type === 'sep') {
+      // a constraint keyword reached through a `&`/`,`-separated sub-list is just as direct —
+      // recurse into the element (mirrors getTypeParamElementKeywords' `sep` arm).
+      scanConstraint((expr as { element: RuleExpr }).element);
     }
   };
   for (const rule of grammar.rules) {
@@ -3157,6 +3161,7 @@ function detectDeclarations(grammar: CstGrammar, tokenNames: Set<string>): DeclI
     if (expr.type === 'ref') return isBlockRule(expr.name);
     if (expr.type === 'seq' || expr.type === 'alt') return expr.items.some(containsBlockRef);
     if (expr.type === 'quantifier' || expr.type === 'group') return containsBlockRef(expr.body);
+    if (expr.type === 'sep') return containsBlockRef(expr.element);
     return false;
   }