semantic: reject bare case-declarations without a block

[cs01]

Motivation

#597 turned out to be caused by `parser-native`'s switch_case iteration silently dropping the trailing `return` when a bare case body contained a `[lexical_declaration, if, return]` sequence. Wrapping the case in `{}` fixes it. Other bare multi-statement case bodies may be lurking undetected in the compiler source.

The TypeScript community solved this exact class with the `no-case-declarations` ESLint rule. We should enforce it at the semantic-pass layer so future bugs in this category are compile errors, not silent-wrong native output.

Proposal

New semantic pass in `src/semantic/case-declarations-checker.ts`:

1. Walk every `SwitchStatement` in the AST (or every desugared if-ladder that came from a switch).
2. For each case's `consequent`, if any statement is a `variable_declaration` / `lexical_declaration` AND the consequent is not a single `BlockStatement` wrapping all of it: emit a compile error pointing at the declaration.
3. Fix suggestion in the error: "wrap the case body in braces: `case X: { ... }`".

Wire into `LLVMGenerator.generateParts()` alongside `checkClosureMutations`, `checkUnionTypes`, etc.

Why this is the right fix

Root cause of #597 is deeper in parser-native's tree-sitter handling of bare case bodies — real fix is there, but until that lands, a compile-time rejection is a cheap guard against silent-wrong output. TypeScript itself rejects this pattern in strict mode (`no-case-declarations`), so the constraint is already familiar to users.

Scope

• One semantic pass (~20-40 LOC).
• No existing test fixture changes expected — clean compiler source should already be block-wrapped after regression: checkMissingReturns false-positives on transformExpression when chad-native.ts has 8+ registerStdlib calls (introduced in #583) #597 lands.
• Fails CI on any bare case-decl regression.

Related: #597 (the bug this prevents future variants of).

[cs01]

Investigated. Blocker uncovered.

What's in the AST at semantic-pass time: the TS-based parser (parser-ts/handlers/statements.ts transformSwitchToIfElse) already desugars every switch into an if/else if chain before semantic passes run. SwitchStatement nodes never reach generateParts() — so a src/semantic/ pass can't see them. The check has to live in the parser handlers (both parser-ts and parser-native).

Prototype worked: added checkCaseDeclarations() in parser-ts/handlers/statements.ts at the top of transformSwitchToIfElse, walks TS AST clauses directly, rejects any clause whose statements aren't a single Block AND contain a VariableStatement / FunctionDeclaration / ClassDeclaration. Fixture tests/fixtures/semantic/case-bare-decl.ts correctly errored at build time.

Blocker: the ChadScript compiler's own source src/parser-native/transformer.ts has ~20 bare-case-decl sites, all of the exact pattern #597 described (case "foo": const x = ...; if (x) { ... } break;). Wrapping them in { ... } is the obvious fix, but produces a new failure:

.build/chad build src/chad-native.ts -o .build/chad-stage1
Error: array index 0 out of bounds (length 0)

The comment above one of them (line ~293) explains: // NOTE: no block braces — ChadScript's switch codegen drops block-scoped cases. So the native switch codegen silently drops statements inside block-wrapped cases — a second, distinct bug.

Options:

1. Fix the native switch codegen to correctly handle case X: { ... } (real fix; unblocks this + probably other latent issues). Probably 1-2 days, not hours.
2. Narrow the check so it only fires on patterns that literally match regression: checkMissingReturns false-positives on transformExpression when chad-native.ts has 8+ registerStdlib calls (introduced in #583) #597's signature (decl + conditional + return, no block). Ugly and leaky.
3. Ship the check + auto-rewrite bare cases during parsing (both parser-ts and parser-native), preserving the original statement sequence so the native compiler sees the flat form it already handles. Middle-ground; might work if the auto-wrap only happens logically (not via the existing block-dropping codegen).

Stopping per the 1-2 hour budget rule. Option 1 is the right fix but it's its own PR.