fix(ir): resolve named-const array dims (0083) + materialize literal slice args (0084)

Two silent-miscompile codegen fixes:

0083 — named-const array dimension. `TypeResolver.resolveCompound`'s array
arm resolved the dimension with `if int_literal ... else 0`, so a named const
(`N :: 16; [N]T`) hit the silent `else 0`: the array became 0-length / 0-byte
and element access ran out of bounds (garbage for scalars, bus error for
slice/pointer/struct elements). The arm now delegates the dimension to
`inner.resolveArrayLen` (symmetric with `inner.resolveInner` for the element).
The stateful `Lowering.resolveArrayLen` evaluates it as a compile-time integer
across the comptime-constant / generic-value / module-global const tables and
emits a diagnostic — no fabricated length — when it isn't one.

0084 — `.[...]` literal passed directly as a call arg. `lowerArrayLiteral`
always yields an aggregate array value; the array→slice conversion is the
caller's job. The local-bound var-decl path did it, but the call-arg coercion
path had no array→slice arm, so `classify([N]T, []T)` returned `.none` and the
raw array was passed where a slice was expected (callee read its {ptr,len}
header off the wrong bytes → 0 / garbage / segfault). `classify` now returns a
new `.array_to_slice` plan for same-element `[N]T → []T`, and `coerceToType`
emits the existing `array_to_slice` op — identical to the local-bound path.

Regressions (fail-before/pass-after demonstrated on the pre-fix compiler):
  examples/0140-types-named-const-array-dim.sx (s64 + string + struct elems)
  examples/0141-types-slice-literal-direct-call-arg.sx (string + []s64)

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

src/ir/lower.zig

@@ -11612,6 +11612,55 @@ pub const Lowering = struct {
         return self.resolveTypeWithBindings(node);
     }
 
+    /// Fixed-array dimension hook for `TypeResolver.resolveCompound`. A literal
+    /// `[16]T` and a named-const `N :: 16; [N]T` must resolve to the SAME length:
+    /// the dimension is a compile-time integer, looked up in the comptime / value
+    /// / module-const tables the stateful lowering owns. A dimension that isn't a
+    /// compile-time integer is a hard error — emitting a diagnostic (rather than
+    /// fabricating a 0 length, which gives a 0-byte array and out-of-bounds
+    /// element access, issue 0083).
+    pub fn resolveArrayLen(self: *Lowering, len_node: *const Node) u32 {
+        if (self.comptimeArrayDim(len_node)) |n| {
+            if (n < 0) {
+                if (self.diagnostics) |d|
+                    d.addFmt(.err, len_node.span, "array dimension must be non-negative, got {}", .{n});
+                return 0;
+            }
+            return @intCast(n);
+        }
+        if (self.diagnostics) |d|
+            d.addFmt(.err, len_node.span, "array dimension must be a compile-time integer constant", .{});
+        return 0;
+    }
+
+    /// Evaluate a fixed-array dimension to a compile-time integer: a literal, or
+    /// a name bound to an integer in the comptime-constant (`OS`/loop cursors),
+    /// generic-value (`$N`), or module-global const (`N :: 16`) tables. Returns
+    /// null when the dimension isn't a compile-time integer.
+    fn comptimeArrayDim(self: *Lowering, node: *const Node) ?i64 {
+        return switch (node.data) {
+            .int_literal => |lit| lit.value,
+            .identifier => |id| self.comptimeIntNamed(id.name),
+            .type_expr => |te| self.comptimeIntNamed(te.name),
+            else => null,
+        };
+    }
+
+    /// Resolve a name to a compile-time integer across the three const tables.
+    fn comptimeIntNamed(self: *Lowering, name: []const u8) ?i64 {
+        if (self.comptime_constants.get(name)) |cv| switch (cv) {
+            .int_val => |iv| return iv,
+            else => {},
+        };
+        if (self.comptime_value_bindings) |cvb| {
+            if (cvb.get(name)) |v| return v;
+        }
+        if (self.program_index.module_const_map.get(name)) |ci| {
+            if (ci.value.data == .int_literal) return ci.value.data.int_literal.value;
+        }
+        return null;
+    }
+
     /// Resolve a type node, checking type_bindings first for generic type params.
     pub fn resolveTypeWithBindings(self: *Lowering, node: *const Node) TypeId {
         // Pack-index in a type position: `$<pack>[<lit>]` resolves to the
@@ -13984,6 +14033,7 @@ pub const Lowering = struct {
             .ptr_int_bitcast => return self.builder.emit(.{ .bitcast = .{ .operand = val, .from = src_ty, .to = dst_ty } }, dst_ty),
             .narrow => return self.builder.emit(.{ .narrow = .{ .operand = val, .from = src_ty, .to = dst_ty } }, dst_ty),
             .widen => return self.builder.emit(.{ .widen = .{ .operand = val, .from = src_ty, .to = dst_ty } }, dst_ty),
+            .array_to_slice => return self.builder.emit(.{ .array_to_slice = .{ .operand = val } }, dst_ty),
         }
     }