Anonymous interface synthesis from inline parameter types

[guybedford]

Hoist directly-inline { ... } parameter types into named interfaces, so consumers get a typed builder instead of a &Object they have to construct manually.

The motivating shape — Cloudflare's SendEmail.send(builder: { ... }) — previously emitted as

pub async fn send_with_builder(this: &SendEmail, builder: &Object)
    -> Result<EmailSendResult, JsValue>;

forcing every caller to assemble the JS object and the string | EmailAddress polymorphism by hand. With this change ts-gen synthesizes a SendEmailBuilder interface as if the user had declared

interface SendEmailBuilder {
  from: string | EmailAddress;
  to: string | string[];
  subject: string;
  // ...
}
interface SendEmail {
  send(builder: SendEmailBuilder): Promise<EmailSendResult>;
}

and the existing pipeline lights up the rest: dictionary classification, property setters, the bare-string-vs-object union expansion, the required-prop-tracking builder, fallible build() -> Result<_, JsValue>.

Naming

<Parent><ParamSegment> PascalCased. The parameter's own identifier takes priority — SendEmail.send(builder: ...) → SendEmailBuilder, DispatchNamespace.get(name, args: ...) → DispatchNamespaceArgs. Falls back to the member's JS name when the parameter is destructured or otherwise unnamed (e.g. WorkflowInstance.sendEvent({ event }) → WorkflowInstanceSendEvent).

Collisions add a numeric suffix: a class with two methods both taking an (options: { ... }) parameter produces FooOptions and FooOptions2. The deduplication uses the same used_type_names set that already tracks every other type in the module, so synthesized names also avoid colliding with hand-written declarations.

Hoisting scope

Only top-level inline literals in parameter position are hoisted. Anonymous types nested inside generics, unions, arrays, or other literals follow the regular type-mapping rules and erase to Object. Inline literals inside a hoisted interface's body recurse using the synthesized parent's name.

The synthesized interface goes through the exact same parse pipeline as a hand-written interface Foo { ... }. No special path, no parallel construction logic — convert_interface_decl and the new synthesis site both call a shared interface_from_signatures(name, type_params, extends, signatures, ...) helper that owns member conversion and classification. Real interfaces and synthesized ones are indistinguishable in the IR by design.

CONVENTIONS

The convention catalogue gains an "Anonymous interface synthesis" section explaining the rule and naming. The doc also drops its previous numbered structure in favour of a plain table of contents linking to section anchors — the numbering was bookkeeping that drifted whenever sections moved, and the prose flow now uses anchor links between sections directly.

Tests

• All 9 fixture snapshots re-blessed; the workers-types diff shows the expected synthesized types: SendEmailBuilder, AiGatewayOptions, D1PreparedStatementOptions / ...Options2, DispatchNamespaceArgs, WorkflowInstanceSendEvent. Each gets the full dictionary-builder treatment.
• Integration tests pass: 6 (es_module_lexer) + 12 (node_console).
• just clippy and just fmt-check clean.