Guided `ete create` skill + `--output-profile`: scope generated artifacts to the consumer's actual need

[ebootheee]

Summary

Add a guided, interactive skill (and the --output-profile flag it would
wrap) that takes a user from .xlsx + "what are you actually trying to do?"
to only the artifacts that use case needs — instead of always running the
full, expensive per-sheet engine emit.

Motivation

Regenerating two ~80 MB PE-platform models for the engine-integration consumer
(the "Mippy request" tracked in ROADMAP.md) made something concrete: the
most expensive artifact to generate is often the least-needed one.

A downstream integration (a build-time engine contract for a production app)
typically consumes only the slim contract:

• _ground-truth.json (compact)
• named-outputs.json / named-inputs.json
• cell-types.json
• manifest.json

…and then runs its own returns/waterfall math (the delta-cascade path), or
just spot-checks baseCaseValue on import to fail the build on drift. It rarely
imports the giant transpiled per-sheet modules at all.

Yet those per-sheet modules are exactly what the slow tail of ete init spends
its time (and memory) producing — hundreds of MB, dominated by one or two huge
sheets. Today users only discover this after waiting through the full emit and
then using ~1% of the output. There's currently no knob to skip the module emit
(only --emit-debug, which adds more).

Proposal

1. A first-class --output-profile on ete init:

Profile	Emits	For
contract	ground truth (compact) + named-outputs/inputs + cell-types + manifest. Skips the per-sheet engine module emit entirely.	Wiring the model into a downstream app at build time
analysis	manifest + ground truth + CLI-readable artifacts (summary/scenario/sensitivity), no debug	Interactive Q&A / scenarios via the ete CLI
full	everything, incl. per-sheet modules + --emit-debug	Full offline recompute / model rebuild

The contract profile is the important one: the named maps' baseCaseValue
comes from ground truth, not from running the engine, so we can produce the
entire downstream contract without emitting the per-sheet modules — cutting
the dominant cost for the most common production consumer. (Ties into the
parser/emitter perf issue.)

2. A guided skill (ete create, or a Claude Code skill) that:

1. Asks what the user wants — one-shot analysis & scenarios? a build-time
   engine-integration contract? full offline recompute?
2. Picks the matching --output-profile + flags for them.
3. Walks init → manifest doctor → validate, then prints a copy-paste
   integration block: how to read the named maps, fail the build on a
   baseCaseValue mismatch, and drive what-ifs via named-inputs
   affectsOutputs (invalidate only affected outputs).
4. Surfaces "model-owner question" cases — e.g. a base-case output that is
   legitimately 0 (the MIP-gating case, request feat: scenario analysis CLI (V3) #7) — so a consumer doesn't
   mistake faithful reproduction for a bug.

Acceptance

• A new user goes from .xlsx + "I'm wiring this into a downstream app" to the
  validated slim contract set plus an integration snippet, without ever
  generating or waiting on the full per-sheet engine modules.
• ete init --output-profile contract is documented in the README and exercised
  by a test.

Notes

There's already a skill/SKILL.md (PE language → CLI translation); this is a
complementary onboarding/scaffolding skill focused on scoping the output to
the goal, not on querying an already-built model.