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.

examples/lisp/CLAUDE.md

@@ -61,11 +61,12 @@ the shape so a regression is easy to recognise.
    emit both halves of the str. `vstr` still does manual
    `p.text = s` (semantically equivalent, no longer required).
 
-6. **`(slice | E)` tagged-union returns drop `slice.len`.** Still
-   present. The wwstage return convention is AX=tag, DX=payload1,
-   CX=payload2 — a 24-byte slice header doesn't fit. Inline the
-   slice-building loop into the caller. See `eval`'s argument-eval
-   inline.
+6. **(retired) `(slice | E)` tagged-union returns drop `slice.len`.**
+   The return ABI now uses 4 regs (AX=tag, DX=ptr, CX=len, R8=cap),
+   covering slice-payload variants up to 32B. The inline args-eval
+   in `eval` is still there but no longer required — `apply` could
+   factor it back out into a `(slice | rterror)` helper. Left as a
+   readability cleanup; not a correctness fix.
 
 7. **(retired) `xs[i].kind` drops the trailing field load.** cgdot
    now handles N_INDEX bases. Builtins are back to

examples/lisp/lisp_test.ww

@@ -50,7 +50,7 @@ fn faili(name: str, why: str, got: i64) void = {
 	os.write(2, ": ".ptr, 2u64);
 	os.write(2, why.ptr, why.len: u64);
 	os.write(2, " got=".ptr, 5u64);
-	let s: str = strconv.i64tos(got, strconv.DEC);
+	let s: str = strconv.i64tos(got, strconv.base.DEC);
 	os.write(2, s.ptr, s.len: u64);
 	os.write(2, "\n".ptr, 1u64);
 	nfail += 1;
@@ -396,7 +396,7 @@ export fn main() i32 = {
 	// ---- summary ----
 	if (nfail == 0) {
 		os.write(1, "\nlisp_test: ".ptr, 12u64);
-		let ts: str = strconv.i64tos(ntotal: i64, strconv.DEC);
+		let ts: str = strconv.i64tos(ntotal: i64, strconv.base.DEC);
 		os.write(1, ts.ptr, ts.len: u64);
 		os.write(1, "/".ptr, 1u64);
 		os.write(1, ts.ptr, ts.len: u64);
@@ -404,10 +404,10 @@ export fn main() i32 = {
 		return 0;
 	};
 	os.write(2, "\nlisp_test: ".ptr, 12u64);
-	let fs: str = strconv.i64tos(nfail: i64, strconv.DEC);
+	let fs: str = strconv.i64tos(nfail: i64, strconv.base.DEC);
 	os.write(2, fs.ptr, fs.len: u64);
 	os.write(2, " of ".ptr, 4u64);
-	let ts: str = strconv.i64tos(ntotal: i64, strconv.DEC);
+	let ts: str = strconv.i64tos(ntotal: i64, strconv.base.DEC);
 	os.write(2, ts.ptr, ts.len: u64);
 	os.write(2, " failed\n".ptr, 8u64);
 	return 1;

examples/lisp/lispcore.ww

@@ -655,7 +655,7 @@ fn next(L: *lexer) (i32 | parserr | eof) = {
 	// list parse_expr will reject it; here we just tag it.
 	if (a.len == 1 && a[0] == '.': u8) { L.curkind = tkind.DOT; return 0; };
 	if (allnum(a)) {
-		let r = strconv.stoi64(a, strconv.DEC);
+		let r = strconv.stoi64(a, strconv.base.DEC);
 		match (r) {
 		case let v: i64 => {
 			L.curkind = tkind.INT;
@@ -1491,7 +1491,7 @@ fn obuf_puts(s: str) void = {
 };
 
 fn obuf_putint(v: i64) void = {
-	let s: str = strconv.i64tos(v, strconv.DEC);
+	let s: str = strconv.i64tos(v, strconv.base.DEC);
 	let i: i32 = 0;
 	for (i < s.len) { obuf_putc(s.ptr[i]); i += 1; };
 };