w6c+selfhost+lib: Hare-style variadic call sites

Param-decl `name: T...` (Tparam.variadic=1, type []T), call-site
gather of N args into a fresh `[N]T`, forward via `xs...`, full
selfhost mirror, and lib/fmt graduated to the Hare shape.

Frontend:
  - parse: `T...` after a param's type stamps Node.op=TK_ELLIPSIS
    and breaks out (variadic must be last).
  - check: resolve_type N_TFN / build_fn_type wrap the param type
    as []T and set tp->variadic. N_CALL accepts either a tail of
    args assignable to T (gather) or a single `xs...` spread of
    []T (forward); both bypass the "too many args" check on the
    variadic slot.
  - type: type_eq compares Tparam.variadic.

Cgen (cstage):
  - call site: when the callee has a variadic last param,
    materialise the tail args into a frame-resident `[N]T` via
    localoff, write a 24B slice descriptor (ptr,len,cap), and
    splice a synthesised N_IDENT into args[] so the downstream
    widen/eval/pop loops see one slice slot. Tagged-element types
    route each store through cg_widen_tagged_store. Forwarding
    skips gather: the N_SPREAD wrapper is replaced with its inner
    slice expression. Empty form writes {nil,0,0}. args[] / widen[]
    bump from 16 to 64 to accommodate Hare's mixed-arg printers.

Selfhost mirror:
  - lib/ww/parse: `T...` mark on N_PARAM.op.
  - cgen: varargseq counter on Cg; scanlocals reserves
    @vararg_d_N + @vararg_sl_N per variadic call (seq recorded on
    N_CALL.uval so cgcall picks the same names). cgcall does the
    same gather/forward and N_IDENT splice. cgfnparams treats
    variadic params as 24B slice slots via a synthesised TSLICE
    tnode. pushargsrev skips the tagged-widen detection for
    variadic params (effective type is []T, not tagged).
  - rhstargetname now recognises N_TRUE/N_FALSE/N_RUNELIT and
    typed N_INTLIT so the variant-tag lookup finds bool/rune/iN
    variants instead of falling through to "first non-str" (which
    misassigned tag 0 to bool in tagged unions like formattable).

lib/fmt graduated: print/println/fprint/fprintln/errorln/fatal
take `args: formattable...`. Bare `error` (no -ln) is skipped —
the leaf name collides with strconv's `type error = !(invalid |
overflow)` under the driver's flat namespace.

Tests: 5 new e2e rows (plain gather, zero-arg, tagged element,
forwarding, fmt.println end-to-end). lib/CLAUDE.md workaround
paragraph replaced with the Hare-shape description.

lib/CLAUDE.md

@@ -26,18 +26,14 @@ Signatures mirror Hare too, modulo:
   buffer (`strings.dup`, `strings.concat`) still return an owned
   `str` that callers free via `os.free(r.ptr, r.len: u64)`.
 
-- Call-site variadic sugar (`fmt::println(42)`) doesn't land yet.
-  The receive side does — `fmt.formattable` is a tagged union of
-  the printable scalar types, and `fmt.printv` / `fmt.printlnv`
-  take an explicit `[]formattable` slice. Until the call-site
-  gather is implemented, callers either hand-build the slice:
-      let args: [2]fmt.formattable;
-      args[0] = "count: ": fmt.formattable;
-      args[1] = 42i64: fmt.formattable;
-      fmt.printlnv(args[0:2]);
-  or compose to a single str via strconv.i64tos + strings.concat:
-      fmt.println(strconv.i64tos(42, strconv.base.DEC));
-  `lib/fmt` is intentionally print-string-only — no `printf`-family.
+- Call-site variadic sugar matches Hare. `fn f(args: T...)` declares
+  a Hare-style variadic; call sites either gather N args into a
+  fresh `[]T` (`fmt.println(42, "hi", true)`) or forward an existing
+  slice with `xs...` (`fprintln(fd, args...)`). The bare `T...` form
+  in tagged unions still means spread-flatten (`(...inner | E)`);
+  the two uses don't overlap because `T...` only attaches to a
+  *param* decl. `lib/fmt` is intentionally print-string-only — no
+  `printf`-family.
 
 - `(T | U)` sum-typed parameters dispatch via `match` inside the
   callee. `strings.byteindex(haystack: str, needle: (str | rune))`,