w6c+wcc/check: infer [_]T array length from initializer element count (fix #7)

`[_]T = [...]` (canonical Hare array-length inference) silently
miscompiled to a zero-length array: the parser already left the array
type's length child nil as the infer sentinel — distinct from an
explicit [N] — but neither checker stamped the real count, so `len(x)`
returned 0 with no diagnostic (rule-7 silent miscompile). Module-level
was worse on wwstage, where `x.len` on ANY global array (even an
explicit [N]) fell to the SB fallback and mis-emitted `MOVQ len(SB), AX`
(linker: undefined reference to len).

The length lives in the stamped TYPE and cgen already keys stride /
length / data-emission off it, so stamping the inferred count at the one
checker inference point closes it permanently (rob's #7 ruling):

  - check.c clet + module-level N_LET pass-2: count the initializer's
    elements and patch the array type's length (the Sym too, so a later
    x.len reads the inferred alen). No-init / non-array init can't infer
    -> loud error, never a silent zero-length array.
  - check.ww inferarraylen: the wwstage twin — stamp a synthesized
    N_INTLIT length child before resolvewalk caches the array tinfo;
    same loud-error rule. Idempotent for the module-level double-call.
  - cgenexpr.ww cgdot: the missing wwstage arm for a top-level [N]T
    global's .len / .ptr (cstage cgen.c:8011 already had it).
  - cgenutil.ww letslotsize: drop the now-redundant [_] slot-size
    intercept — a workaround for this very bug; the stamped length flows
    through the general slotsize path (rule 7).

Both stages converge byte-identical; new table-driven test 684 covers
[_]int/[_]str/[_]u8 local + module-level, len + element read-back,
dual-stage runtime + asm byte-id, plus three negative no-infer rows.

selfhost/cmd/wcc/cgenexpr.ww

@@ -2441,6 +2441,41 @@ fn cgdot(c: *cgen, n: *node) void = {
 			};
 		};
 	};
+	// Top-level [N]T global pseudo-fields (#7): `.len` is the static
+	// element count (immediate from the array type node's length child);
+	// `.ptr` is the array's base address (LEAQ name(SB)). Without this a
+	// module-level array's `x.len` falls to the module-qualified SB
+	// fallback below and mis-emits `MOVQ len(SB), AX` (linker: undefined
+	// reference to len). Mirror of the local-array arm above and cstage
+	// cg_base_cap's `aimm(bu->alen)` immediate (cgen.c:1692).
+	if (lhs != nil) {
+		if (lhs.kind == nkind.N_IDENT) {
+			let gtn: *node = letvartnode(c, lhs.str);
+			if (gtn != nil) {
+				if (gtn.kind == nkind.N_TARRAY) {
+					if (streq(fld, "ptr")) {
+						emitline("\tLEAQ\t");
+						emitsymname(c, lhs.str);
+						emitline("(SB), AX\n");
+						return;
+					};
+					if (streq(fld, "len")) {
+						let lenn: *node = gtn.rhs;
+						let alen: i64 = 0i64;
+						if (lenn != nil) {
+							if (lenn.kind == nkind.N_INTLIT) {
+								alen = lenn.uval: i64;
+							};
+						};
+						emitline("\tMOVQ\t$");
+						emitint(alen);
+						emitline(", AX\n");
+						return;
+					};
+				};
+			};
+		};
+	};
 	// Top-level struct global field read — LEAQ name(SB), CX then
 	// load at fi.foff(CX). Mirrors the local "Direct struct local"
 	// branch above, swapping the BP frame slot for the global VA.