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/conversions.zig

@@ -42,6 +42,7 @@ pub const CoercionResolver = struct {
         ptr_int_bitcast, // ptr ↔ int
         widen, // same kind, dst wider
         narrow, // same kind, dst narrower
+        array_to_slice, // [N]T → []T (materialize backing storage + header)
         none, // nothing applies — pass the value through
     };
 
@@ -65,6 +66,20 @@ pub const CoercionResolver = struct {
             }
         }
 
+        // Fixed array → slice of the same element: an aggregate array value
+        // (e.g. a `.[...]` literal passed directly as a call arg) needs to be
+        // materialized into addressable storage and wrapped in a {ptr,len}
+        // header. Without this the array value is passed where a slice is
+        // expected — the callee reads the header off the wrong bytes (issue
+        // 0084). The local-bound path already does this conversion on its own.
+        if (!src_ty.isBuiltin() and !dst_ty.isBuiltin()) {
+            const si = self.l.module.types.get(src_ty);
+            const di = self.l.module.types.get(dst_ty);
+            if (si == .array and di == .slice and si.array.element == di.slice.element) {
+                return .array_to_slice;
+            }
+        }
+
         // Optional → Concrete unwrap (narrowing).
         if (!src_ty.isBuiltin()) {
             const src_info = self.l.module.types.get(src_ty);