prepare.cppm: split into the primary interface and thirteen implementation files

The physical split (design step 4-5 combined, given the time this
decomposition has already taken): src/build/prepare.cppm keeps only
the module preamble, the exported helper functions (with bodies --
splitting each into a bare declaration plus a definition in a separate
exports.cpp was not done; at 2414 lines the file is under the 2500
hard cap without it, so this was deferred rather than risk a
mechanical error for no required outcome), and prepare_build's own
exported declaration with its default arguments. Everything else moved
under src/build/prepare/:

  state.cppm             implementation partition :state -- PrepareState,
                          the five structs P4 needed hoisted, and every
                          phase function's declaration.
  driver.cpp              prepare_build's definition.
  manifest.cpp            P0.
  toolchain.cpp           P1 + P2.
  toolchain_decision.cpp  P5 (split out of toolchain.cpp: P1+P2+P5
                          together were 2526 lines, over the hard cap).
  xlings.cpp              P3.
  graph_load.cpp          P4a (loadVersionDep).
  graph.cpp               P4b (the worklist engine).
  features.cpp            P6-P8.
  target_side.cpp         P9.
  scan.cpp                P11.
  plan.cpp                P13.

Two visibility problems, both from the same cause -- an implementation
partition does not implicitly see its module's primary interface the
way an implementation unit does, so it must import it explicitly:
  - The preamble helpers moved out of their anonymous namespace in the
    previous commit for exactly this reason, but ToolPurpose (a type,
    not a module-linkage function) still needed an explicit `export`:
    :state names it in PrepareState's own member list, and a partition
    only sees what its imports export.
  - state.cppm added `import mcpp.build.prepare;` for BuildOverrides,
    BuildContext, PlanNote, CacheMode and TcOrigin, all exported types
    PrepareState's declaration itself names.
Every other file compiled against the split on the first attempt: the
extensive state.<name> threading done in every prior commit was
already correct, this just gave it its own files.

All twelve source files are at or under the 2500-line hard cap; nine
are at or under the 2000-line target. prepare.cppm (2414) and three
implementation files (target_side.cpp 1968, features.cpp 2052,
toolchain.cpp 2136, graph.cpp 2345, plan.cpp 2392) sit between the two
because splitting them further was not required to satisfy the cap
and each remaining cut point would have needed its own escaping-
closure audit.

GCC 16.1 builds this cleanly: the primary interface imports no
partition, :state is an implementation partition imported only by
implementation units, satisfying the constraint verified in
.agents/docs/2026-09-27-mcpp-2026.9.27.1-ecosystem-plan.md §4.3.

Golden fixture diff against the baseline is empty; mcpp test:
129/129 (root) plus every member with tests (versioning, platform,
manifest, toolchain-model, buildmcpp) individually green.

Author: speak-agent

src/build/prepare.cppm

@@ -0,0 +1,122 @@
+module mcpp.build.prepare;
+import :state;
+
+import mcpp.build.prepare_inputs;
+
+import std;
+import mcpp.targetside;
+import mcpp.diag;
+import mcpp.build.refusal;
+import mcpp.xlings.address_set;
+import mcpp.build.version_floor;
+import mcpp.home;
+import mcpp.platform.axis;
+import mcpp.libs.json;
+import mcpp.log;
+import mcpp.manifest;
+import mcpp.source_kind;
+import mcpp.modgraph.glob;
+import mcpp.modgraph.graph;
+import mcpp.modgraph.scanner;
+import mcpp.modgraph.validate;
+import mcpp.toolchain.clang;
+import mcpp.toolchain.hostflags;   // the compile-token producer the package std module reuses
+import mcpp.toolchain.cenv;        // [c-abi] declaration → compiler configuration (design 2026-09-18)
+import mcpp.toolchain.cenv_probe;  // [c-abi] declaration is checked, not trusted (design §3.2)
+import mcpp.toolchain.predefines;  // the macros this engine defines: contract and emission in one module
+import mcpp.toolchain.cppfly;
+import mcpp.toolchain.detect;
+import mcpp.toolchain.dialect;
+import mcpp.toolchain.fingerprint;
+import mcpp.toolchain.msvc;
+import mcpp.toolchain.registry;
+import mcpp.toolchain.linkmodel;
+import mcpp.toolchain.gcc;
+// For `resolve_version_match` / `list_installed_versions`: a bare compiler
+// family named by the dependency graph resolves to a concrete version through
+// exactly the path `mcpp toolchain default <family>` uses.
+import mcpp.toolchain.lifecycle;
+import mcpp.toolchain.stdmod;
+import mcpp.freestanding.target;   // the target sysroot layout (libdir)
+import mcpp.freestanding.linkline; // the ISA profile, for the std module command
+import mcpp.toolchain.post_install;
+import mcpp.toolchain.abi;
+import mcpp.toolchain.triple;
+import mcpp.build.linkage_form;   // #519 — which form each dependency takes
+import mcpp.build.plan;
+import mcpp.build.schedule.policy;
+import mcpp.build.flags;          // compute_flags — the per-role contracts (#418)
+import mcpp.build.distribution;   // dist::Role / dist::Contract to_string
+import mcpp.platform.capacity;   // the host fallback handed to schedule::decide
+import mcpp.build.graph_shape;  // #407: the graph says which mode wrote it
+import mcpp.build.runtime_validation;  // declared artifact -> identity verdict
+import mcpp.build.cache_key;
+import mcpp.pack.abi_tag;      // the tag a prebuilt dependency is checked against
+import mcpp.pack.prebuilt;     // …and the check itself
+import mcpp.pack.stage_tree;   // where `${mcpp.stage_dir}` points, and its manifest
+import mcpp.build.build_program;
+import mcpp.build.directives;   // directive table: mark / fold_private_tail
+import mcpp.build.tool_store;   // #355 host tools: store layout + key + overrides
+import mcpp.build.dep_graph;    // queries over the resolved edge graph
+import mcpp.build.provisions;   // #359 build-time provisions: table + propagation
+import mcpp.build.resources;    // #365 Windows resources: synthesise / scan / find rc
+import mcpp.build.backend;      // BuildOptions for the tool sub-build
+import mcpp.build.ninja;        // make_ninja_backend — driving that sub-build
+import mcpp.lockfile;
+import mcpp.config;
+import mcpp.xlings;
+import mcpp.xlings.subos_info;
+import mcpp.xlings.runtime_selection;
+import mcpp.runtime.binding;
+import mcpp.platform.runtime_search;
+import mcpp.toolchain.post_install;
+import mcpp.platform;
+import mcpp.platform.macos;
+import mcpp.build.runner_lookup;
+import mcpp.fetcher;
+import mcpp.fetcher.progress;
+import mcpp.pm.resolver;
+import mcpp.pm.index_spec;
+import mcpp.pm.index_contract;
+import mcpp.pm.index_route;
+import mcpp.pm.index_refresh;
+import mcpp.pm.mangle;
+import mcpp.pm.compat;
+import mcpp.pm.dep_spec;
+import mcpp.pm.dependency_selector;
+import mcpp.pm.lock_io;
+import mcpp.version_req;
+import mcpp.ui;
+import mcpp.log;
+import mcpp.wire;               // Severity, for PlanNote (#699 item 2, E3)
+import mcpp.fallback.install_integrity;
+import mcpp.bmi_cache;
+import mcpp.project;
+
+namespace mcpp::build {
+
+std::expected<BuildContext, std::string>
+prepare_build(bool print_fingerprint,
+              bool includeDevDeps,
+              std::vector<mcpp::manifest::Target> extraTargets,
+              BuildOverrides overrides) {
+    PrepareState state(print_fingerprint, includeDevDeps,
+                        std::move(extraTargets), std::move(overrides));
+    pending_flag_words_notes().clear();
+
+    if (auto r = phase0_manifest_and_workspace(state); !r) return std::unexpected(r.error());
+    if (auto r = phase1_toolchain_spec_and_axes(state); !r) return std::unexpected(r.error());
+    if (auto r = phase2_define_toolchain_resolver(state); !r) return std::unexpected(r.error());
+    if (auto r = phase3_xlings_before_graph(state); !r) return std::unexpected(r.error());
+    if (auto r = phase4a_graph_load(state); !r) return std::unexpected(r.error());
+    if (auto r = phase4b_graph_worklist(state); !r) return std::unexpected(r.error());
+    if (auto r = phase5_toolchain_after_graph(state); !r) return std::unexpected(r.error());
+    if (auto r = phase6_features_and_host_tools(state); !r) return std::unexpected(r.error());
+    if (auto r = phase9_target_side(state); !r) return std::unexpected(r.error());
+    if (auto r = phase11_scan(state); !r) return std::unexpected(r.error());
+
+    return phase13_finish(state);
+}
+
+
+} // namespace mcpp::build