feat(P2): add toolchain ProviderCapabilities dispatch layer

Centralise the scattered is_clang/is_gcc/targetTriple.find("msvc") checks
into a single capabilities_for(tc) query in src/toolchain/provider.cppm.

The new ProviderCapabilities struct exposes has_import_std, has_scan_deps,
has_modules, stdlib_id ("libstdc++" / "libc++" / "msvc-stl"), and
archive_format ("ar" / "llvm-ar" / "lib.exe") — one place to update when
a new compiler variant is added.

No existing call-sites are changed in this commit; provider.cppm documents
the provider concept and is ready for callers to migrate to incrementally.

Author: Sunrisepeak

src/toolchain/provider.cppm

@@ -0,0 +1,111 @@
+// mcpp.toolchain.provider — provider capabilities dispatch.
+//
+// Documents the "provider concept": each toolchain variant (GCC/libstdc++,
+// Clang/libc++, Clang/MSVC-STL) has a distinct set of capabilities.
+// Previously these decisions were scattered as ad-hoc is_clang(tc) /
+// is_gcc(tc) / targetTriple.find("msvc") checks. This module centralises
+// them into a single query point.
+//
+// Usage:
+//   auto caps = mcpp::toolchain::capabilities_for(tc);
+//   if (caps.has_import_std) { ... }
+
+export module mcpp.toolchain.provider;
+
+import std;
+import mcpp.toolchain.model;
+
+export namespace mcpp::toolchain {
+
+// ─── ProviderCapabilities ────────────────────────────────────────────────────
+//
+// Describes what a particular toolchain instance can do.  All fields have
+// safe defaults (false / empty) so callers that only care about one flag
+// do not need to guard the rest.
+
+struct ProviderCapabilities {
+    // True when the toolchain ships a prebuilt `std` module source
+    // (bits/std.cc for GCC, std.cppm / std.ixx for Clang variants) and
+    // Toolchain::stdModuleSource has been populated by enrich_toolchain().
+    bool has_import_std = false;
+
+    // True when clang-scan-deps (or an equivalent dep-scanner) is available
+    // alongside the compiler binary.  Currently only Clang provides this.
+    bool has_scan_deps = false;
+
+    // True when the compiler supports C++ named modules at all.
+    // All three supported compilers do; kept for future use when we add
+    // compilers that don't (e.g. old MSVC versions, ICC).
+    bool has_modules = true;
+
+    // Canonical stdlib identifier:
+    //   "libstdc++"  — GCC, or Clang targeting a non-MSVC triple on Linux/macOS
+    //   "libc++"     — Clang with libc++ (xim:llvm toolchain, or Apple Clang)
+    //   "msvc-stl"   — Clang targeting x86_64-pc-windows-msvc
+    //   ""           — Unknown / not yet detected
+    std::string stdlib_id;
+
+    // Archive tool name used for static libraries:
+    //   "ar"       — GCC / system binutils
+    //   "llvm-ar"  — Clang (llvm-ar is preferred; falls back to system ar)
+    //   "lib.exe"  — MSVC (future)
+    //   ""         — Unknown
+    std::string archive_format;
+};
+
+// Determine provider capabilities from an already-detected toolchain.
+// All fields are derived from tc.compiler + tc.targetTriple + tc.hasImportStd
+// so the result is deterministic and has no side-effects.
+ProviderCapabilities capabilities_for(const Toolchain& tc);
+
+} // namespace mcpp::toolchain
+
+// ─── Implementation ──────────────────────────────────────────────────────────
+
+namespace mcpp::toolchain {
+
+ProviderCapabilities capabilities_for(const Toolchain& tc) {
+    ProviderCapabilities caps;
+
+    caps.has_import_std = tc.hasImportStd;
+    caps.has_modules    = true;   // all supported compilers handle modules
+
+    switch (tc.compiler) {
+        case CompilerId::GCC: {
+            caps.has_scan_deps   = false;   // GCC has no clang-scan-deps equivalent
+            caps.stdlib_id       = "libstdc++";
+            caps.archive_format  = "ar";
+            break;
+        }
+
+        case CompilerId::Clang: {
+            // Clang targeting MSVC uses MSVC STL, not libc++.
+            // We detect this the same way clang.cppm's enrich_toolchain does:
+            // by checking the target triple for "msvc".
+            bool msvc_target = tc.targetTriple.find("msvc") != std::string::npos;
+
+            caps.has_scan_deps  = true;     // clang-scan-deps lives beside clang++
+            caps.stdlib_id      = msvc_target ? "msvc-stl" : "libc++";
+            caps.archive_format = "llvm-ar";
+            break;
+        }
+
+        case CompilerId::MSVC: {
+            // Pure MSVC (cl.exe) — not yet fully supported, but stubs are here
+            // so callers can branch on it without another unknown-compiler guard.
+            caps.has_scan_deps  = false;
+            caps.stdlib_id      = "msvc-stl";
+            caps.archive_format = "lib.exe";
+            break;
+        }
+
+        case CompilerId::Unknown:
+        default:
+            // Leave all caps at their safe defaults (false / "").
+            break;
+    }
+
+    return caps;
+}
+
+} // namespace mcpp::toolchain