w6c+selfhost: route f64/f32 struct-field load/store through X0

cgexpr leaves float results in X0, not AX, but the struct-field paths
emitted MOVQ AX,off(BX) and MOVQ off(BX),AX — so every store wrote
garbage and every load read garbage, except by accidental register
survival across an unrelated call. examples/lisp only worked because
parsef's X0 happened to live across the broken MOVQ shuffle into
vfloat; any inserted f64 op between them would silently corrupt.

Wire MOVSD/MOVSS X0,… (and the matching loads) into eight field
sites on both compilers: alloc(T{...}), p.x = v through local/ptr/
global, chained r.sub.x = v, *p = v for *f64, let v: T = T{...},
base.x reads, *T.x reads, and chained a.b.c.x reads.

83/83 lisp_test probes still pass; bootstrap reaches a byte-stable
fixed point at ww3 == ww4.

selfhost/cmd/wcc/cgenstmt.ww

@@ -452,13 +452,26 @@ fn cglet(c: *cgen, n: *node) void = {
 							let fn_: str = fi.fname;
 							if (streq(fn_, fname)) {
 								cgexpr(c, fieldnode.lhs);
-								let sop: str = fieldstoreop(fi);
-								emitline("\t");
-								emitline(sop);
-								emitline("\tAX, ");
-								emitoff((off + fi.foff): i64);
-								emitline("(BP)\n");
-								fi = nil;
+								// f64/f32 struct-literal field init: cgexpr left
+								// the value in X0, store via MOVSD/MOVSS.
+								if (isfloattype(c, fi.tnode)) {
+									let mov: str = "MOVSD";
+									if (isf32type(c, fi.tnode)) { mov = "MOVSS"; };
+									emitline("\t");
+									emitline(mov);
+									emitline("\tX0, ");
+									emitoff((off + fi.foff): i64);
+									emitline("(BP)\n");
+									fi = nil;
+								} else {
+									let sop: str = fieldstoreop(fi);
+									emitline("\t");
+									emitline(sop);
+									emitline("\tAX, ");
+									emitoff((off + fi.foff): i64);
+									emitline("(BP)\n");
+									fi = nil;
+								};
 							} else {
 								fi = fi.finext;
 							};