fix(0124): large stack arrays lower to in-place access, not first-class values

Two lowering sites materialized a local array as a whole LLVM value;
the legalizer scalarizes each such op into one SelectionDAG node per
element, and at ~64K elements the DAG combiner segfaults
(DAGCombiner::visitMERGE_VALUES → ReplaceAllUsesWith).

- lowerVarDecl: an array-typed `---` initializer emits NO store — the
  slot stays uninitialized instead of receiving a whole-array undef
  store. The tuple zero-init carve-out stays; non-array `---` keeps
  the undef store. The interp is unchanged either way (slots start
  .undef).
- lowerIndexExpr: element reads on an array with addressable storage
  GEP the storage and load one element — the general-expression
  sibling of 0110's lowerFor fix — without value-lowering the object
  (a dead whole-array load would still reach the DAG). Storage-less
  arrays keep the index_get fallback.

Sibling shape filed as 0125: any_to_string's per-array-type arms still
pass the array by value, so a 64K+ array type + any {} print crashes.

Regression: examples/0055-basic-large-stack-array.sx (sx build
segfaulted pre-fix). 22 .ir snapshots re-pinned: removed undef stores
and ig.tmp spills, in-place gep+load (instruction-shape-only churn,
reviewed).

src/ir/lower/stmt.zig

@@ -260,9 +260,9 @@ pub fn lowerVarDecl(self: *Lowering, vd: *const ast.VarDecl) void {
         const ty = self.resolveType(ta);
         const slot = self.builder.alloca(ty);
         if (vd.value) |val| {
-            // = --- (undef_literal) on tuple types: zero-initialize
             if (val.data == .undef_literal and !ty.isBuiltin()) {
                 const ti = self.module.types.get(ty);
+                // = --- (undef_literal) on tuple types: zero-initialize
                 if (ti == .tuple) {
                     var field_vals = std.ArrayList(Ref).empty;
                     defer field_vals.deinit(self.alloc);
@@ -278,6 +278,16 @@ pub fn lowerVarDecl(self: *Lowering, vd: *const ast.VarDecl) void {
                     }
                     return;
                 }
+                // `---` on an array: explicitly uninitialized — no store.
+                // A whole-array undef store is a store of nothing that
+                // LLVM's legalizer scalarizes into one DAG node per
+                // element (issue 0124: SelectionDAG segfault at ~64K).
+                if (ti == .array) {
+                    if (self.scope) |scope| {
+                        scope.put(vd.name, .{ .ref = slot, .ty = ty, .is_alloca = true });
+                    }
+                    return;
+                }
             }
             // A compile-time float initializer narrowing into an integer
             // local follows the unified rule (integral folds, non-integral