fix(ir): evaluate constant-expression array dimensions (0083)

A constant-FOLDABLE expression array dimension (`[M + 1]`, `[M * N]`,
`[N - M]`, nested `[M + N - 1]`, parenthesised `[(M + 1) * 2]`, mixing
untyped and typed module consts) was wrongly rejected as "not a
compile-time integer constant" even though every operand is
compile-time-known. Attempts 1-3 resolved only a bare named-const dim or
a literal; an expression dim must be EVALUATED, not rejected.

Fix: the shared dim resolver now routes the dimension through a single
constant integer-expression evaluator (`program_index.evalConstIntExpr`)
that folds integer `+ - * / %` and unary negate over literals and
named/typed module consts, recursively (parentheses carry no AST node).
The leaf-name lookup is delegated via `ctx.lookupDimName`, so the
stateful body-lowering path (`Lowering`, which also sees comptime
constants and generic `$N` values) and the stateless registration path
(`type_bridge.StatelessInner`, module consts only) share the EXACT SAME
folding logic and cannot diverge — an expression dim via a type alias
resolves identically to the direct form.

No-fabrication discipline unchanged: a genuinely non-comptime dimension
(runtime local, non-comptime call, unbound name) or arithmetic that
overflows / divides by zero still yields null -> `.unresolved` -> the
same clean compile-halting diagnostic, never a fabricated length.

- examples/0144-types-const-expr-array-dim.sx: every expression form,
  direct vs alias, scalar / string / struct element types (fails on the
  pre-fix compiler, passes after).
- examples/1129 re-pointed at a genuinely non-const dimension
  (`[get()]s64`, a runtime call) so it still proves the stateless
  clean-halt (a foldable expression is no longer an error).
- program_index.test.zig: unit test for evalConstIntExpr folding and
  clean-halt-on-non-const.

issues/0083-named-const-array-dimension-miscompiled.md

@@ -49,6 +49,29 @@
 > alias for s64/string/struct, forward-ref alias, nested) and
 > `examples/1129-diagnostics-array-dim-not-const.sx` (an unresolvable computed dim
 > halts with a clean diagnostic + non-zero exit, not a fabricated 0-length array).
+>
+> **Const-expression dimensions (attempt 4).** Attempts 1–3 resolved only a BARE
+> named-const dim (`[M]`) or a literal (`[5]`); any constant-FOLDABLE *expression*
+> dimension (`[M + 1]`, `[M * N]`, `[N - M]`, nested `[M + N - 1]`, parenthesised
+> `[(M + 1) * 2]`) was wrongly rejected as "not a compile-time integer constant"
+> even though every operand is compile-time-known. Such a dimension MUST be
+> evaluated, not rejected. Fix: the shared dim resolver now routes the dimension
+> through a single constant integer-expression evaluator
+> (`program_index.evalConstIntExpr`) that folds integer `+ - * / %` and unary
+> negate (parentheses carry no AST node) over literals and named/typed module
+> consts, recursively. The leaf-name lookup is delegated (`ctx.lookupDimName`) so
+> the stateful body-lowering path and the stateless registration path share the
+> EXACT SAME folding logic and cannot diverge — an expression dim via a type alias
+> resolves identically to the direct form. The no-fabrication discipline is
+> unchanged: a genuinely non-comptime dimension (a runtime local, a non-comptime
+> call, an unbound name) — or arithmetic that overflows / divides by zero — still
+> yields null → `.unresolved` → the same clean compile-halting diagnostic, never a
+> fabricated length. Files: `src/ir/program_index.zig` (+`.test.zig`),
+> `src/ir/lower.zig`, `src/ir/type_bridge.zig`. Regression:
+> `examples/0144-types-const-expr-array-dim.sx` (every expression form, direct vs
+> alias, scalar / string / struct element types); `1129` re-pointed at a genuinely
+> non-const dimension (`[get()]s64`, a runtime call) so it still proves the
+> stateless clean-halt.
 
 ## Symptom
 A fixed array whose dimension is a module-global integer constant (`N :: 16;