wcc: Hare-style !T error marker on tagged-union variants

A type prefixed with `!` is flagged as an error variant. When any
variant in a tagged union carries the flag, `?` propagation uses
those (and only those) as the error subset; the unflagged variant
is the success type. The legacy "first variant = success" rule still
applies when no `!`-flag is present, so existing code keeps working.

- TK_NOT in parsetype → N_TBANG wrapper (lhs = inner type expr).
  Appended to Nkind tail for wwdump-diff byte stability.
- resolve_type N_TBANG: wraps primitives in a fresh Type copy so the
  iserror bit doesn't taint shared globals like ty_str/ty_i32; flips
  the bit in place on NAMED (already unique per alias decl).
- Type.iserror; type_named and typedecl inherit it from under.
- New check.c helpers: tagged_has_errflag, tagged_is_error_variant,
  tagged_success_type. N_TRYPROP uses them to find the error subset
  and verify each error variant is propagatable to the enclosing
  return.
- cgen mirrors with cg_tagged_success_tag + cg_variant_is_error.
  `?` compares AX against the success tag (no longer always 0) and
  remaps each error variant's tag for the enclosing fn. `!` aborts
  on any non-success tag.

strconv.invalid and strconv.overflow now use `!`-flagged shape
(`!i32` and `!void`) — visible signal in the API surface that they
are error types, matching Hare. The (i64 | invalid | overflow)
return shape and behavior are unchanged for callers; their match
arms still bind the same way.

Selfhost: lib/ww/parse/parse.ww recognises `!T` and emits N_TBANG.
The selfhost typechecker and cgen ignore the flag — none of the
selfhost sources use `!`, so byte-identity gates are unaffected.
The selfhost mirror catches up when there's a source using it.

cmd/wcc/ww.h

@@ -296,6 +296,7 @@ typedef enum {
 	N_TYPETEST,	/* lhs is T  →  bool */
 	N_TYPEASSERT,	/* lhs as T  →  T (abort if tag mismatch) */
 	N_VOIDLIT,	/* `void` as expression — zero-size void value */
+	N_TBANG,	/* `!T` — error-flagged type. lhs = inner type. */
 
 	N_LAST
 } Nkind;
@@ -403,6 +404,10 @@ struct Type {
 	int		variadic;
 	const char	*name;	/* named alias / debug */
 	Type		*under;	/* underlying resolved type for NAMED */
+	int		iserror;/* Hare-style `!T` error mark; propagates
+				 * through NAMED aliases. Variants with
+				 * iserror=1 are the propagation target of
+				 * the `?` operator. */
 };
 
 extern Type	*ty_void, *ty_bool, *ty_rune;