This adds support for dynamic unions: a #[wasm_bindgen] enum that mixes
string-literal variants with single-field tuple variants is exported as an
untagged TypeScript union and dispatched dynamically at the JS↔Rust boundary.

The motivation is to express common JavaScript shapes — "loading" | string | SomeClass | OtherClass — as a single Rust enum that can be match-ed
exhaustively. Discrimination is dynamic: each variant is tested in
declaration order via as_string for string literals and TryFromJsValue
for typed payloads.

#[wasm_bindgen]
pub struct Foo { /* ... */ }

#[wasm_bindgen]
pub enum ApiResult {
    Success = "success",
    Failure = "failure",
    Data(String),
    Foo(Foo),
}

produces the TypeScript

export type ApiResult = "success" | "failure" | string | Foo;

Resolves #2088, resolves #2153.

What's implemented

• New schema entry DYNAMIC_UNION and per-variant descriptor exports
  (__wbg_dynamic_union_<name>_<idx>) so cli-support can resolve variant
  TypeScript names through the normal descriptor pipeline.
• ast::DynamicUnion parser path triggered by any tuple-style variant on a
  #[wasm_bindgen] enum. The previous error "enum variants with associated
  data are not supported" is removed; mixed unit + tuple variants are now
  parsed as a dynamic union.
• Generated IntoWasmAbi / FromWasmAbi / TryFromJsValue /
  OptionIntoWasmAbi / OptionFromWasmAbi / From<T> for JsValue impls,
  plus WasmDescribe carrying the variant type list.
• String-literal variants are coalesced into a single as_string check
  with an inner match, so worst-case dispatch is one string read
  regardless of how many literal variants exist. Literal variants always
  win against a generic String arm regardless of declaration order.
• cli-support plumbing: Descriptor::DynamicUnion,
  AdapterType::DynamicUnion, incoming/outgoing externref lowering, and
  option-position handling so Option<DynamicUnion> works.
• TypeScript rendering: AuxDynamicUnionVariant::{Literal, Type} defers
  variant TS rendering to JS-generation time, where renamed types resolve
  through qualified_to_identifier. A reference closure
  (expand_typescript_refs) walks transitively-referenced types so nested
  unions and string enums used as variants emit their full type aliases.
• String enums and dynamic unions both emit export type (was bare
  type) so the alias is a named module export.
• private flag honoured by string enums and dynamic unions to suppress
  the export keyword.

#[wasm_bindgen(fallback)]

The new enum-level fallback attribute makes the last tuple variant an
unconditional catch-all. This is the supported pattern for unions whose
trailing variant has no meaningful runtime check (e.g., interface-only
imports — types declared via extern \"C\" { type Foo; } with
typescript_type but no JS-side runtime construct, whose instanceof
check always returns false).

#[wasm_bindgen]
extern \"C\" {
    #[wasm_bindgen(typescript_type = \"Shape\")]
    pub type Shape;
}

#[wasm_bindgen(fallback)]
pub enum ApiResult {
    Loading = \"loading\",
    Empty = \"empty\",
    Anything(Shape),
}

renders as \"loading\" | \"empty\" | Shape. Strings \"loading\" and
\"empty\" route to their named variants; anything else is unconditionally
accepted as Anything(_).

Nesting and Option

A variant payload may itself be another dynamic union or a string enum,
and the union may appear inside Option:

#[wasm_bindgen]
pub enum Inner { Foo = \"foo\", Bar = \"bar\", Number(u32) }

#[wasm_bindgen]
pub enum Outer { Loading = \"loading\", Wrapped(Inner), Bare(Foo) }

generates:

export type Inner = \"foo\" | \"bar\" | number;
export type Outer = \"loading\" | Inner | Foo;

Option<DynamicUnion> works in both argument and return positions and
renders as the standard T | null | undefined / T | undefined pair.

C-style enum TryFromJsValue fix

This PR fixes a separate bug uncovered by the new tests: c-style enum
TryFromJsValue was applying JS unary + coercion via f64::try_from,
silently coercing strings, booleans, null, and arrays into numbers. As a
result dyn_into::<MyEnum>() on a string would produce a valid enum
value (typically the variant with discriminant 0, since NaN as u32 = 0),
violating the TryFromJsValue contract.

The conversion now uses value.as_f64(), which only succeeds on actual
JS numbers. This affects two surfaces:

• dyn_into::<MyEnum>() for c-style enums correctly returns Err for
  non-numeric input.
• Vec<MyEnum> from JS rejects elements that aren't numbers (the
  existing tests/wasm/enum_vecs.rs::test_invalid expected this but was
  previously a no-op because the bypass coerced through).

Round-trip benchmark

benches/enum_roundtrip.rs measures string-enum vs dynamic-union round-trip
cost through a JS shim. On Node 25 in release mode:

• string_enum_roundtrip: 118.77 ns
• dynamic_union_roundtrip: 119.77 ns

Within ~1%. The runtime cost difference between the two encodings is
effectively noise — a developer-facing comment on ToTokens for ast::StringEnum
notes this and outlines the path to subsume string enums into dynamic
unions in a future PR.

Test coverage

• tests/wasm/enums.rs — round-trips now go through JS shims declared in
  tests/wasm/enums.js to actually exercise the dispatcher (previously
  these called exported Rust functions Rust-to-Rust, bypassing
  into_abi / from_abi entirely). Tests cover string-literal variants,
  primitive payloads, exported and imported types, nesting, Option, and
  the new fallback attribute.
• crates/cli/tests/reference/dynamic-union.{rs,d.ts,bg.js,js,wat} —
  full reference fixture covering literals, fallback, exported struct,
  imported type (annotated with typescript_type), nesting,
  Option<Wrapper>, and a private variant.
• crates/typescript-tests/src/dynamic_union.{rs,ts} — TS-side jest
  tests asserting the generated .d.ts exposes union types as named
  aliases, that variants typecheck both as literals and as object payloads,
  that nested literals dispatch through the outer→inner chain, and that
  Option<Wrapped> typechecks as T | null | undefined.
• crates/macro/ui-tests/invalid-enums.{rs,stderr} — new error coverage
  for variants with named fields, variants with multiple unnamed fields,
  and unit variants without a string discriminant in a tuple-bearing enum.
• tests/wasm/enum_vecs.js — updated to assert the correct error
  message ("array contains a value of the wrong type") that the strict
  TryFromJsValue now produces.

Naming

The feature is named dynamic union throughout — "dynamic" describes the
discrimination mechanism (runtime inspection per variant), distinguishing it
from compile-time TS unions and from Rust's own tagged enums. The original
draft used "discriminated union" which is technically the opposite of
what this is (these are untagged at the JS boundary).

Schema

Schema hash bumped to 9718506702724923631.