w6c+selfhost+lib: cgen quality batch + lib Hare-shape graduation

Six fixes across the toolchain, surfaced by lib/lisp porting work.

  1. f64 compound assigns (`acc += d`, `-=`, `*=`, `/=`). Both stages
     load slot → X1, OP X0 into X1, store back (ADDSD/SUBSD/MULSD/
     DIVSD are reg-reg only). Previous MOVSD-overwrite dropped the
     OP. Locals and top-level lets.

  2. Top-level `[N]u8` arrays + `&arr[i]`. let_emit_size grows a
     TY_ARRAY branch so zero-init DATAW lands; cgindex / N_INDEX
     store / `&base[i]` all detect a global array base and use
     LEAQ name(SB) instead of LEAQ (BP). TK_AMP no longer pre-
     evaluates the operand as a value-load — `&base[i]` computes
     base + i*esz directly. Unblocks Hare's static-buffer pattern:
     strconv.{u64,i64,f64}tos graduate to module-level `*_buf`
     arrays and return owned views.

  3. Cross-module `pkg.Enum.MEMBER`. Nested N_DOT chains that
     don't fold to a known shape now emit `MOVQ <leaf>(SB), AX`
     (mirrors the bare-IDENT unresolved fallback), so isolation
     probes — and the test 990 cgen-match floor — stay consistent
     across stages. strconv exposes `base` as a real `enum i32`;
     callers updated. The `main` exemption (linker entry-point
     keeps bare name even when not exported) mirrors C-side
     collectmods into selfhost cgendecl.

  4. Sum-typed parameter ABI. lib/bytes.{index,rindex} take
     `(u8 | []u8)` needle; lib/strings.byteindex / rbyteindex take
     `(str | rune)` needle (Hare-shaped; the byte-wise misnomer
     `index` is dropped). tagged_arg_size cap bumps to 48 (6 int
     regs), with a new partial-fit branch on the callee: when an
     N-word tagged arg overflows remaining regs, fill what fits and
     stitch the rest from positive BP offsets. scanlocals MCASE
     handles slice binds (24B) and walks each arm with a saved /
     restored seenmark set so two arms naming the same local each
     get their own slot — matches cstage's per-arm scope reset.

  5. 4-reg tagged-return ABI (AX=tag, DX=word0, CX=word1, R8=word2),
     up from 3 regs. Slice-payload variants (`([]T | E)`, slot 32B)
     round-trip ptr/len/cap end-to-end. Every receive site updates:
     let-init via cgwidentaggedstore, match scrutinee spill, cgindex
     tagged-element load (both N_IDENT and fallback bases),
     pushargsrev tagged-ident arg (reads word count from slot size),
     cgreturn slice variant in the shuffle path.

  6. `expr: TaggedAlias` is a widening, not a re-interpret. C cgen +
     selfhost cgwidentaggedstore peel an N_CAST whose destination IS
     the union — so cgexpr's natural shape (str: AX=ptr, BX=len;
     slice: AX=ptr, BX=len, CX=cap) is consumed by the matching
     concrete-variant branch instead of being misread as a tagged
     AX/DX/CX triple. Inner casts to a concrete variant (`7: i32`)
     keep their type for proper tag lookup. `[N]Alias` arrays
     resolve element size via slotsize + aliaslookup, and aliaslookup
     strips a `pkg.` prefix so cross-module references work.

lib/fmt grows `formattable = (i64 | str | bool | rune)` plus
`printv` / `printlnv` taking an explicit `[]formattable` slice (the
receive side of Hare's `args: formattable...`). Call-site variadic
gather isn't wired — callers either hand-build the slice or compose
strconv.i64tos + strings.concat.

700_e2e: 114 → 123 rows (f64 compound, top-level u8 arrays + `&buf[i]`,
pkg.Enum.MEMBER, sum-typed (str|rune) and (u8|[]u8) params, 4-reg
slice-return ABI, formattable array). 26/26 tests, bootstrap stable
through ww4.

selfhost/cmd/wcc/cgendecl.ww

@@ -150,10 +150,24 @@ fn scanlocals(c: *cgen, n: *node) i32 = {
 		if (bn.len > 0) {
 			let pat: *node = n.lhs;
 			if (pat != nil) {
-				if (isstrtype(c, pat)) { total += 16; }
-				else { total += 8; };
+				if (isstrtype(c, pat))        { total += 16; }
+				else { if (isslicetype(c, pat)) { total += 24; }
+				else                          { total += 8; }; };
 			};
 		};
+		// Match arms get a fresh local scope at emission time
+		// (cgmatch saves c.locals before each arm and restores
+		// after). scanlocals must mirror that: walk the arm
+		// body with a saved/restored seenmark set so two arms
+		// declaring the same name each get their own slot,
+		// matching the per-arm frame growth the emit phase
+		// produces.
+		if (n.body != nil) {
+			let saved: *local = c.locals;
+			total += scanlocals(c, n.body);
+			c.locals = saved;
+		};
+		return total;
 	};
 	// Tagged-arr/slice index store needs a 24B scratch slot
 	// (`@tagscr`) for cgwidentaggedstore to materialise the source
@@ -346,10 +360,36 @@ fn cgfnparams(c: *cgen, params: *node) void = {
 						idx += 1;
 						w += 1;
 					};
+				} else { if (idx < 6 && nw > 1) {
+					// Partial fit: fill remaining regs, then read
+					// the tail from positive BP offsets. Mirrors
+					// the caller's greedy reg fill in pushargsrev.
+					let off: i32 = localadd(c, nm, slot, p.lhs);
+					let regs_left: i32 = 6 - idx;
+					let w: i32 = 0;
+					for (w < regs_left) {
+						emitline("\tMOVQ\t");
+						emitline(argregname(idx));
+						emitline(", ");
+						emitoff((off + w*8): i64);
+						emitline("(BP)\n");
+						idx += 1;
+						w += 1;
+					};
+					for (w < nw) {
+						emitline("\tMOVQ\t");
+						emitoff((16 + stkcursor*8): i64);
+						emitline("(BP), AX\n");
+						emitline("\tMOVQ\tAX, ");
+						emitoff((off + w*8): i64);
+						emitline("(BP)\n");
+						stkcursor += 1;
+						w += 1;
+					};
 				} else {
 					localaddstack(c, nm, p.lhs, 16 + stkcursor*8);
 					stkcursor += nw;
-				};
+				};};
 			} else { if (isslicetype(c, p.lhs)) {
 				if (idx + 3 <= 6) {
 					let off: i32 = localadd(c, nm, 24, p.lhs);
@@ -430,7 +470,12 @@ fn cgfn(c: *cgen, fn_: *node) void = {
 				};
 				a = a.next;
 			};
-			if (!isffi) {
+			// `main` is the linker entry-point convention; even
+			// when not marked `export`, it must keep its bare
+			// name so w6l's _start can resolve `CALL main(SB)`.
+			// Mirror of cmd/w6c/cgen.c collectmods exemption.
+			let isentry: bool = streq(fn_.str, "main");
+			if (!isffi && !isentry) {
 				os.write(1, fn_.module.ptr, fn_.module.len: u64);
 				os.write(1, ".".ptr, 1u64);
 			};