fix(ir): exhaustive named-const array dims (0083) + nested slice-literal coercion (0085)

Makes the F0.4 fixes exhaustive across every resolution / nesting path.

0083 — named-const array dimension, stateless paths. Attempt 1 fixed the
stateful resolver (direct local decls, struct fields, params, returns) but the
binding-free registration-time resolver (`type_bridge`, used for type aliases
`Arr :: [N]T` and inline union/enum field types) still resolved a named dim with
a silent `else 0`, so `Arr :: [N]s64; a : Arr` and `union { a: [N]s64 }` were
still miscompiled (garbage / bus error). Thread the module-global const table
(`ProgramIndex.module_const_map`) into `type_bridge` alongside the alias map, so
`StatelessInner.resolveArrayLen` resolves a named module-const dim to the same
length everywhere. The remaining unresolvable case (a computed/comptime dim on
the binding-free path, which the stateful path hard-errors) now bails LOUDLY
instead of fabricating a 0 length.

0085 — nested slice-literal elements. `lowerArrayLiteral` lowered each element
with the element type as target but appended the raw value. A nested `.[...]`
element at a slice element type (`[][]s64`) still lowers to an aggregate array
`[N]T`, so the outer aggregate held raw arrays where slice {ptr,len} headers
were expected — indexing the inner slice read a garbage pointer and segfaulted.
After lowering each element, coerce a same-element array to the slice element
type via the existing `array_to_slice` op. The coercion recurses with the
nesting, so `[][]T` and deeper materialize at every level — local-bound AND
direct-call-argument forms.

Regressions (fail-before/pass-after demonstrated on the pre-fix compiler):
  examples/0140-types-named-const-array-dim.sx — extended with type-alias,
    nested [N][M]T, and union-field named dims (s64 / string / struct elems)
  examples/0142-types-nested-slice-literal-elements.sx — [][]s64 + [][]string,
    local-bound vs direct-arg
  src/ir/type_bridge.test.zig — named-const dim resolves to literal length

Gate: zig build, zig build test, bash tests/run_examples.sh (388 passed).
Issues 0083 and 0085 marked RESOLVED.

examples/0140-types-named-const-array-dim.sx

@@ -1,32 +1,69 @@
 // A fixed array whose dimension is a module-global named constant
 // (`N :: 16; [N]T`) has the same layout as a literal-dimension array
 // (`[16]T`): correct length and element stride for scalar, slice/pointer
-// (string), and struct element types.
+// (string), and struct element types — on EVERY type-resolution path:
+// direct local decls, type aliases (`Arr :: [N]T`), nested fixed arrays
+// (`[N][M]T`), and inline union fields. The named dim must resolve to the
+// same length whether it flows through the stateful body-lowering resolver
+// or the stateless registration-time resolver (type_bridge).
 // Regression (issue 0083): a named-const dim resolved to length 0, giving a
 // 0-byte alloca — scalar reads returned garbage and string/struct elements
-// bus-errored.
+// bus-errored. The alias and union-field paths went through the stateless
+// resolver, which had no const table and silently fabricated a 0 length.
 #import "modules/std.sx";
 
 N :: 4;
+M :: 3;
 
 P :: struct { x: s64; y: s64; }
 
+// Type aliases whose dimension is the named const N (stateless registration).
+Arr :: [N]s64;
+SArr :: [N]string;
+
+// Inline union field with a named-const dimension (stateless registration).
+U :: union { a: [N]s64; tag: s64; }
+
 main :: () {
-    // Scalar elements: store then read back.
+    // Scalar elements (direct local): store then read back.
     a : [N]s64 = ---;
     a[0] = 7;
     a[3] = 42;
     print("scalar a0={} a3={}\n", a[0], a[3]);
 
-    // Slice/pointer elements (string): used to bus-error.
+    // Slice/pointer elements (string, direct local): used to bus-error.
     s : [N]string = ---;
     s[0] = "hi";
     s[1] = "yo";
     print("string s0={} s1={}\n", s[0], s[1]);
 
-    // Struct elements.
+    // Struct elements (direct local).
     ps : [N]P = ---;
     ps[0] = P.{ x = 1, y = 2 };
     ps[2] = P.{ x = 5, y = 6 };
     print("struct p0x={} p0y={} p2x={}\n", ps[0].x, ps[0].y, ps[2].x);
+
+    // Type-alias dimension (scalar): same layout as the direct `[N]s64`.
+    aa : Arr = ---;
+    aa[0] = 11;
+    aa[3] = 99;
+    print("alias a0={} a3={}\n", aa[0], aa[3]);
+
+    // Type-alias dimension (string): no bus error, correct reads.
+    sa : SArr = ---;
+    sa[0] = "al";
+    sa[2] = "ok";
+    print("alias s0={} s2={}\n", sa[0], sa[2]);
+
+    // Nested fixed array `[N][M]s64`: both dimensions are named consts.
+    grid : [N][M]s64 = ---;
+    grid[0][0] = 1;
+    grid[3][2] = 8;
+    print("nested g00={} g32={}\n", grid[0][0], grid[3][2]);
+
+    // Inline union field with a named-const dimension.
+    u : U = ---;
+    u.a[0] = 70;
+    u.a[3] = 7;
+    print("union u0={} u3={}\n", u.a[0], u.a[3]);
 }

examples/0142-types-nested-slice-literal-elements.sx

@@ -0,0 +1,44 @@
+// A nested array/slice literal (`.[.[1, 2], .[3, 4]]`) at an expected slice-of-
+// slices type (`[][]s64`) materializes each inner `[N]T` literal as a real `[]T`
+// slice, so indexing the inner slice in the callee reads element contents
+// correctly — for both the local-bound form and the direct-call-argument form.
+// Regression (issue 0085): inner literals were appended as raw `[N]T` arrays
+// under an element type of `[]T`, so the outer aggregate's elements were arrays
+// where slice {ptr,len} headers were expected; indexing the inner slice read a
+// garbage pointer and segfaulted. The per-element array->slice materialization
+// recurses with the nesting, so every level coerces.
+#import "modules/std.sx";
+
+sum_nested :: (xss: [][]s64) -> s64 {
+    total := 0;
+    i := 0;
+    while i < xss.len {
+        j := 0;
+        while j < xss[i].len { total += xss[i][j]; j += 1; }
+        i += 1;
+    }
+    return total;
+}
+
+count_x :: (xss: [][]string) -> s64 {
+    n := 0;
+    i := 0;
+    while i < xss.len {
+        j := 0;
+        while j < xss[i].len { if xss[i][j] == "x" { n += 1; } j += 1; }
+        i += 1;
+    }
+    return n;
+}
+
+main :: () {
+    // numeric [][]s64 — local-bound vs direct-arg both sum to 10.
+    local : [][]s64 = .[.[1, 2], .[3, 4]];
+    print("num local={}\n", sum_nested(local));
+    print("num direct={}\n", sum_nested(.[.[1, 2], .[3, 4]]));
+
+    // string [][]string — local-bound vs direct-arg both count 4 "x"s.
+    slocal : [][]string = .[.["x", "a"], .["b", "x"], .["x", "x"]];
+    print("str local={}\n", count_x(slocal));
+    print("str direct={}\n", count_x(.[.["x", "a"], .["b", "x"], .["x", "x"]]));
+}

examples/expected/0140-types-named-const-array-dim.stdout

@@ -1,3 +1,7 @@
 scalar a0=7 a3=42
 string s0=hi s1=yo
 struct p0x=1 p0y=2 p2x=5
+alias a0=11 a3=99
+alias s0=al s2=ok
+nested g00=1 g32=8
+union u0=70 u3=7

examples/expected/0142-types-nested-slice-literal-elements.exit

@@ -0,0 +1 @@
+0

examples/expected/0142-types-nested-slice-literal-elements.stderr

@@ -0,0 +1 @@
+

examples/expected/0142-types-nested-slice-literal-elements.stdout

@@ -0,0 +1,4 @@
+num local=10
+num direct=10
+str local=4
+str direct=4