feat: backend= dep knob, [runtime.<cap>] provider= override, [package] platforms

- dep spec backend = "<impl>" — sugar for requesting the dependency's
  backend-<impl> feature (library backend selection knob; verified the dep
  compiles with -DMCPP_FEATURE_BACKEND_<IMPL>).
- [runtime.<capability>] provider = "<pkg>" — explicit provider selection:
  prefers the named provider for matching capabilities (surfaced by why/
  doctor/resolution.json), warns when the provider isn't in the graph.
- [package] platforms = [...] — declared platform support, surfaced by
  mcpp why as the CI matrix hint.

Author: d2learn-org

src/cli.cppm

@@ -3211,6 +3211,25 @@ prepare_build(bool print_fingerprint,
         }
     }
 
+    // Apply [runtime.<capability>] provider = "<pkg>" overrides: prefer the
+    // named provider for matching capabilities (capability name prefix match).
+    // Warn if the named provider isn't in the dependency graph.
+    for (auto& [capKey, prov] : ctx.manifest.runtimeConfig.providerOverrides) {
+        bool found = false;
+        std::stable_partition(ctx.plan.runtimeProviders.begin(),
+                              ctx.plan.runtimeProviders.end(),
+                              [&](const std::pair<std::string, std::string>& pr) {
+            bool match = pr.first.rfind(capKey, 0) == 0 && pr.second == prov;
+            found = found || match;
+            return match;
+        });
+        if (!found) {
+            std::println(stderr,
+                "warning: [runtime.{}] provider = \"{}\" — no such provider in the "
+                "dependency graph for that capability", capKey, prov);
+        }
+    }
+
     // Capability-driven ABI enforcement: if any dependency declares an
     // `abi:<x>` capability, the resolved toolchain must satisfy it. (Toolchain
     // is resolved before the dep graph, so this enforces/diagnoses rather than
@@ -4484,6 +4503,14 @@ int cmd_why(const mcpplibs::cmdline::ParsedArgs& parsed) {
         std::println("toolchain: {}", tc.label());
         std::println("  abi={}  stdlib={}  triple={}", abi_of(tc), tc.stdlibId, tc.targetTriple);
         std::println("  reason: [toolchain] in mcpp.toml if set, else platform-native default");
+        if (!ctx->manifest.package.platforms.empty()) {
+            std::string ps;
+            for (auto& p : ctx->manifest.package.platforms) {
+                if (!ps.empty()) ps += ", ";
+                ps += p;
+            }
+            std::println("  declared platforms: {}  (CI matrix hint)", ps);
+        }
     }
     if (all || topic == "runtime") {
         std::println("runtime library dirs (baked into binary RUNPATH):");

src/manifest.cppm

@@ -37,6 +37,7 @@ struct Package {
     std::string                 license;
     std::vector<std::string>    authors;
     std::string                 repo;
+    std::vector<std::string>    platforms;     // declared supported platforms (CI matrix hint)
 };
 
 struct Language {
@@ -115,6 +116,9 @@ struct RuntimeConfig {
     std::vector<std::filesystem::path> libraryDirs;   // relative to package root
     std::vector<std::string>           dlopenLibs;    // runtime-loaded sonames
     std::vector<std::string>           capabilities;  // host/system capabilities
+    // [runtime.<capability>] provider = "<pkg>" — explicit provider selection
+    // (the three-tier knob: default/auto → explicit override).
+    std::map<std::string, std::string> providerOverrides;
 };
 
 // `[target.<triple>]` — per-target overrides.
@@ -437,6 +441,7 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
     if (auto v = doc->get_string("package.license"))     m.package.license     = *v;
     if (auto v = doc->get_string("package.repo"))        m.package.repo        = *v;
     if (auto v = doc->get_string_array("package.authors")) m.package.authors  = *v;
+    if (auto v = doc->get_string_array("package.platforms")) m.package.platforms = *v;
 
     // [package].standard (M5.0 new home)
     if (auto v = doc->get_string("package.standard"))    m.package.standard    = *v;
@@ -588,7 +593,8 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
     auto is_dep_spec_key = [](std::string_view k) {
         return k == "path"   || k == "version" || k == "git"
             || k == "rev"    || k == "tag"     || k == "branch"
-            || k == "features" || k == "workspace" || k == "visibility";
+            || k == "features" || k == "workspace" || k == "visibility"
+            || k == "backend";
     };
     auto looks_like_inline_dep_spec = [&](const t::Table& sub) {
         if (sub.empty()) return false;
@@ -620,6 +626,11 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
             for (auto& fv : it->second.as_array())
                 if (fv.is_string()) spec.features.push_back(fv.as_string());
         }
+        // `backend = "<impl>"` — sugar for requesting the dependency's
+        // `backend-<impl>` feature (library-level backend selection knob).
+        if (auto it = sub.find("backend"); it != sub.end() && it->second.is_string()) {
+            spec.features.push_back("backend-" + it->second.as_string());
+        }
         if (auto it = sub.find("rev");     it != sub.end() && it->second.is_string()) {
             spec.gitRev     = it->second.as_string();
             spec.gitRefKind = "rev";
@@ -877,6 +888,15 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
         m.runtimeConfig.dlopenLibs = *v;
     if (auto v = doc->get_string_array("runtime.capabilities"))
         m.runtimeConfig.capabilities = *v;
+    // [runtime.<capability>] provider = "<pkg>" — explicit provider override.
+    if (auto* rt = doc->get_table("runtime"); rt && !rt->empty()) {
+        for (auto& [rk, rv] : *rt) {
+            if (!rv.is_table()) continue;  // flat keys handled above
+            auto& tt = rv.as_table();
+            if (auto it = tt.find("provider"); it != tt.end() && it->second.is_string())
+                m.runtimeConfig.providerOverrides[rk] = it->second.as_string();
+        }
+    }
 
     // [lib] — library root convention (cargo-style).
     if (auto v = doc->get_string("lib.path")) {