w6c+wwstage: emit over-cap tuple return via sret callee-side (#10 Fold A)

A tuple return whose SysV register-return footprint exceeds the caps
(> 4 integer eightbytes or > 2 SSE eightbytes) previously LOUD-STOPPED
at the N_RETURN SEND. Fold A makes the CALLEE emit such a return through
the existing >24B-struct sret skeleton:

  - classifier (cg_sret_retsize / sretretsize) grows a TY_TUPLE arm:
    walk the element footprint over the SAME caps the SEND uses, and
    return the tuple's natural total size (type table) when over-cap,
    else 0. The gp/sse caps are factored to a single shared SSoT
    (TUPLE_GPCAP / TUPLE_SSECAP — cgen.c macros in cstage, cgen.ww defs
    in wwstage) consumed by the classifier AND every emit/receive site
    (the SEND, the destructure guards, the cgcall arg guard) — so
    classify and emit can't disagree in either stage.
  - the SEND replaces the loud-stop with a write-through: cgexpr each
    element, store it through *(@sretarg) at its packed layout offset
    (the t.0/t.1 positional layout), each at its natural width so a
    narrow tail stores MOVL/MOVB not an over-MOVQ (#169); the dest base
    reloads into DX each step since a wide element clobbers AX/BX/CX.
    Then the existing struct-sret epilogue (MOVQ @sretarg->AX; ret).
  - the prologue already wires @sretarg when the classifier is nonzero.

The CALL/receive side is deliberately untouched: the N_MLET/N_MASSIGN
destructure loud-stops stay, so an over-cap tuple return is not yet
usefully callable. The end-to-end round-trip arrives with Fold B (#10-B).

Symmetric cstage (cmd/w6c/cgen.c) + wwstage (cgen.ww / cgenstmt.ww /
cgenutil.ww); combined.ww amalgams regenerated. Test 798 asserts the
callee now COMPILES (no loud-stop) and w6c vs w6c_ww .s byte-identical
across all-wide, str, narrow-tail, and float-over-cap shapes; no runtime
row (uncallable until Fold B). All 236 pass incl. 990-997 byte-id.

Makefile

@@ -344,6 +344,7 @@ TESTS	= $(BIN)/test_smoke $(BIN)/test_lex $(BIN)/test_parse $(BIN)/test_check \
 	  $(BIN)/test_xmod_valglobal_run \
 	  $(BIN)/test_xmod_valglobal_dot_run \
 	  $(BIN)/test_len_strglobal_run \
+	  $(BIN)/test_tuple_sret_callee \
 	  $(BIN)/test_widen_pad_zero_run \
 	  $(BIN)/test_named_ptr_alias_variant_widen \
 	  $(BIN)/test_single_field_struct_zeroinit \
@@ -840,6 +841,15 @@ $(BIN)/test_len_strglobal_run: test/wcc/797_len_strglobal_run.c \
 		$(LIB)/libwwrt.a | $(BIN)
 	$(CC) $(CFLAGS) -o $@ $<
 
+# #10 Fold A (wide tuple-return / sret, CALLEE side): an over-cap tuple
+# return (> 4 GP or > 2 SSE eightbytes) now compiles via sret instead of
+# loud-stopping at the SEND. Compile + cs==ww byte-id only — the receive
+# stays loud-stopped (Fold B wires the round-trip). Self-contained probes.
+$(BIN)/test_tuple_sret_callee: test/wcc/798_tuple_sret_callee.c \
+		$(BIN)/ww $(BIN)/w6c $(BIN)/w6c_ww $(BIN)/w6a $(BIN)/w6l \
+		$(LIB)/libwwrt.a | $(BIN)
+	$(CC) $(CFLAGS) -o $@ $<
+
 # #15: widening a bare *vtable into a NAMED-alias variant (`stream` =
 # *vtable) of `(file | stream)` must compute the right tag, not default
 # to tag 0. Both-stage byte-id + runtime, plus a degenerate-ambiguity