Prototype A: vanilla async launch functions over the typed engine

[kyleve]

Problem

This is a prototype for comparison, not a default-merge candidate. The question it answers: how much of the combinator engine's (#116) safety survives if setup and teardown become ordinary async functions — and what does the simplification actually buy?

The combinator LaunchPlan bought compile-checked data flow at the cost of a whole concept layer: step protocol conformances, plan combinators/builders, erased node internals, and one extra hop between "what the launch does" and where you read it.

Changes

Setup and teardown are now vanilla async functions driven through a LifecycleContext:

{ context in
    let services = try await context.step(.openStore) { … }     // Void → WhereServices
    let session  = try await context.step(.startSession) { … }  // uses `services`
    if !model.hasOnboarded {
        try await context.gate(OnboardingGate(), value: session)
    }
    try await context.step(.syncAuth) { … }
    context.detached(.reminders) { … }                          // never blocks .ready
    return session                                              // → .ready(session)
}

• Deleted: LaunchPlan + combinators/builders/erased nodes and the LifecycleStep protocol; LifecycleGate slims to id + modes + Value (conditionality is the caller's if; the type survives because the UI registry keys on it). Where's step types fold back into WhereLaunch.launch(for:)/reset(for:) with their doc comments.
• Unchanged: the value-carrying Phase (.ready(Launch), gate handles), the entire LifecycleKitUI layer (container, gate registry — only the proxy's teardown(input:_:) signature changed), cancel-and-drain, superseded-drive rules, promotion semantics, detached drain-before-relaunch, teardown-input release, DetachedFailureReporter.
• Retry and promotion collapse into one code path: re-run the function with the run-once memo. Deliberate semantic change, pinned by a test: plain ifs before a failed step re-evaluate on retry.

What's kept vs. lost (the actual trade)

Guarantee	Combinators (#116)	This prototype
Ordering (use-before-produce)	then constraints	plain data flow through lets — equivalent
Producers can't be skipped	runtime precondition	compile-time (no modes: on the producing overload; if forces an else)
Detached can't be depended on	Output == Void constraint	Void bodies — equivalent
Skipped gate re-evaluates on promotion	engine rule	unmemoized skip + re-run — equivalent, tested
Memoized retry types	combinator-guaranteed casts	ID discipline: one ID = one call site; type-checked memo hits + duplicate-ID traps fire deterministically on first full run
Static structure (nodeIDs, parity tests)	yes	lost — replaced by @_spi(Testing) executed-step recording
Effects between steps	impossible (everything is a node)	new footgun: bare glue re-runs on every re-drive; documented convention + pinning test
Launch/teardown ID collisions	fail-fast precondition	non-issue: per-site memo namespaces

Net: −412 lines of Swift (−443 overall including docs; 1,365(+) / 1,808(−)), one whole concept layer removed, and Where's launch reads top-to-bottom in one function.

Testing

Same coverage shape as the base branch, ported: runner drive/gate/detached/promotion/retry/teardown suites, both seeded fuzz suites (200 randomized functions vs. an independent model, 120 flaky-retry drains — the fuzz now builds its launch closures dynamically), plus new pins for the changed retry semantics, the bare-glue-re-runs rule, and executed-ID recording. LifecycleKitUI suites pass with only construction-site updates; Where suites port mechanically (parity via executed IDs). Full Stuff-iOS-Tests scheme green; ./swiftformat --lint clean.