w6c+selfhost: struct globals — zero-init DATAW + LEAQ-based field access

Extend top-level mutable `let` to cover structs. Same approach as
str / slice: take the field-access base through &name(SB) instead
of off(BP).

  - emit_lets / emitletdataw: emit `sizeof(T)` zero bytes for any
    struct global without a baked-in initialiser. Struct-literal
    init is skipped → undefined symbol at link if used;
  - cgdot read path: when the IDENT base's local lookup misses and
    the name is a struct let, LEAQ name(SB), CX and load the field
    at fi.foff(CX) with the width-aware op (MOVQ / MOVL /
    MOVZBQ / MOVSXD; MOVQ pair for str fields);
  - cgassign write path: parallel handling for plain `=` (incl. str
    fields) and the compound ops (+=, -=) via load → push → eval
    rhs → combine → store with a re-LEAQ between cgexpr clobbers.

Tagged-union fields on struct globals are unsupported in v1 — the
local path's tagged branch isn't generalised yet. Whole-struct
by-value flow through expressions remains NYI (matches the local
status). 630_let_global gains 3 fixtures (read/write, compound +=,
narrow u8 field); selfhost mirror keeps test 990 / 994 / 995 byte
identical; bootstrap fixed point holds.

selfhost/cmd/wcc/cgenexpr.ww

@@ -917,6 +917,42 @@ fn cgdot(c: *cgen, n: *node) void = {
 			};
 		};
 	};
+	// 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.
+	// Field-width-aware op handles MOVQ / MOVL / MOVZBQ / MOVSXD.
+	if (lhs != nil) {
+		if (lhs.kind == nkind.N_IDENT) {
+			let si: *structinfo = letvarstructinfo(c, lhs.str);
+			if (si != nil) {
+				let fi: *fieldinfo = si.fields;
+				for (fi != nil) {
+					if (streq(fi.fname, fld)) {
+						emitline("\tLEAQ\t");
+						emitsymname(c, lhs.str);
+						emitline("(SB), CX\n");
+						if (isstrtype(c, fi.tnode)) {
+							emitline("\tMOVQ\t");
+							emitdispreg(fi.foff: i64, "CX");
+							emitline(", AX\n");
+							emitline("\tMOVQ\t");
+							emitdispreg((fi.foff + 8): i64, "CX");
+							emitline(", BX\n");
+						} else {
+							let op: str = fieldloadop(fi);
+							emitline("\t");
+							emitline(op);
+							emitline("\t");
+							emitdispreg(fi.foff: i64, "CX");
+							emitline(", AX\n");
+						};
+						return;
+					};
+					fi = fi.finext;
+				};
+			};
+		};
+	};
 	// Module-qualified value reference: `mod.name` where `mod`
 	// is nkind.N_IDENT bound as skind.SK_USE and the leaf isn't a local.
 	// Treat as a SB symbol — `MOVQ leaf(SB), AX`. Same fallback
@@ -1517,6 +1553,91 @@ fn cgassign(c: *cgen, n: *node) void = {
 				};
 			};
 		};
+	// Top-level struct global field assignment: `g.f = expr;` and
+	// `g.f += expr;` for a scalar/str field. Reached when the local
+	// lookup miss but the IDENT base is a registered struct `let`.
+	// LEAQ name(SB) into BX/CX takes the place of the frame slot
+	// addressing the local branches use. Compound (PLUSEQ/MINUSEQ)
+	// follows the same load → push → eval → combine → store shape
+	// as the via-ptr local path.
+	if (lhs != nil) {
+		if (lhs.kind == nkind.N_DOT) {
+			let base: *node = lhs.lhs;
+			let fld: str = lhs.str;
+			if (base != nil) {
+				if (base.kind == nkind.N_IDENT) {
+					let bn: str = base.str;
+					if (localfindnode(c, bn) == nil) {
+						let si: *structinfo = letvarstructinfo(c, bn);
+						if (si != nil) {
+							let fi: *fieldinfo = si.fields;
+							for (fi != nil) {
+								if (streq(fi.fname, fld)) {
+									if (n.op == tkind.TK_ASSIGN) {
+										cgexpr(c, n.rhs);
+										if (isstrtype(c, fi.tnode)) {
+											emitline("\tLEAQ\t");
+											emitsymname(c, bn);
+											emitline("(SB), CX\n");
+											emitline("\tMOVQ\tAX, ");
+											emitdispreg(fi.foff: i64, "CX");
+											emitline("\n");
+											emitline("\tMOVQ\tBX, ");
+											emitdispreg((fi.foff + 8): i64, "CX");
+											emitline("\n");
+											return;
+										};
+										let sop: str = fieldstoreop(fi);
+										emitline("\tLEAQ\t");
+										emitsymname(c, bn);
+										emitline("(SB), BX\n");
+										emitline("\t");
+										emitline(sop);
+										emitline("\tAX, ");
+										emitdispreg(fi.foff: i64, "BX");
+										emitline("\n");
+										return;
+									};
+									// Compound on scalar field: load
+									// → push → eval rhs → combine →
+									// store. cgexpr clobbers BX, so
+									// re-LEAQ for the store.
+									let lop: str = fieldloadop(fi);
+									emitline("\tLEAQ\t");
+									emitsymname(c, bn);
+									emitline("(SB), BX\n");
+									emitline("\t");
+									emitline(lop);
+									emitline("\t");
+									emitdispreg(fi.foff: i64, "BX");
+									emitline(", BX\n");
+									emitline("\tPUSHQ\tBX\n");
+									cgexpr(c, n.rhs);
+									emitline("\tPOPQ\tBX\n");
+									if (n.op == tkind.TK_PLUSEQ)  { emitline("\tADDQ\tBX, AX\n"); };
+									if (n.op == tkind.TK_MINUSEQ) {
+										emitline("\tSUBQ\tAX, BX\n");
+										emitline("\tMOVQ\tBX, AX\n");
+									};
+									let sop: str = fieldstoreop(fi);
+									emitline("\tLEAQ\t");
+									emitsymname(c, bn);
+									emitline("(SB), BX\n");
+									emitline("\t");
+									emitline(sop);
+									emitline("\tAX, ");
+									emitdispreg(fi.foff: i64, "BX");
+									emitline("\n");
+									return;
+								};
+								fi = fi.finext;
+							};
+						};
+					};
+				};
+			};
+		};
+	};
 	// Chained `<expr>.field = v` where `<expr>` itself is a chain
 	// of dots resolving to a *struct. Mirrors the C cgen branch
 	// added to close trap 1 (cmd/w6c/cgen.c). Without this, only