feat(toolchain): surface the windows-hosted linux cross in doctor and docs

doctor gains the mirror of its existing mingw probe: on a Windows host it now
also reports whether the linux-musl cross payload is installed. Same shape,
same optional-not-an-error wording, and it derives the package name the same
way to_xim_package() does (`<triple>-gcc`) so the two cannot disagree.

docs/03-toolchains.md gains the section this feature is for, written as the
mirror of "Windows PE via MinGW-w64": the command is spelled identically on
both hosts because cross is not a name in mcpp, just host != target. It also
states the two limits explicitly rather than leaving users to discover them —
linux-gnu from Windows is unsupported (glibc needs the sysroot payloads, which
are Linux-only), and cross-arch from Windows is unsupported (the canadian-cross
payload is built per host arch).

Author: Sunrisepeak

docs/03-toolchains.md

@@ -158,6 +158,41 @@ windows = "gcc@16"            # gcc family on Windows = MinGW-w64
 # legacy value "mingw@16.1.0" keeps working
 ```
 
+## Linux ELF from Windows (`x86_64-linux-musl`, no WSL required)
+
+The mirror of the section above: a Windows machine producing a **fully static
+Linux binary**, with no WSL, no container, and nothing installed system-wide.
+
+```bash
+mcpp build --target x86_64-linux-musl        # from Windows OR Linux
+```
+
+The command is spelled *identically* on both hosts, because "cross" is not a
+name in mcpp — it is just the relation `host ≠ target`. Which payload serves
+the target is resolved automatically: a Linux x86_64 host installs the native
+`musl-gcc`; a Windows host installs a **canadian-cross** GCC
+(built `x86_64-linux-gnu` → runs on `x86_64-w64-mingw32` → emits
+`x86_64-linux-musl`). Both are GCC 16.1.0 and both ship `bits/std.cc`, so
+`import std` works the same either way.
+
+The output is a fully static ELF with no `PT_INTERP` — it runs on any Linux
+distribution regardless of its libc, which is exactly why musl is the target
+that got wired up first:
+
+```console
+$ file mcpp
+mcpp: ELF 64-bit LSB executable, x86-64, statically linked, stripped
+```
+
+`x86_64-linux-gnu` from Windows is **not** supported: a glibc target needs the
+`xim:glibc` and `xim:linux-headers` sysroot payloads, which are published for
+Linux hosts only. The musl target is self-contained and needs neither.
+
+Cross-arch from Windows (e.g. `aarch64-linux-musl`) is not available either —
+the canadian-cross payload is built per host arch. `mcpp toolchain list` shows
+only what the current host can actually install, so if a target is missing from
+the Targets block, that host genuinely cannot serve it.
+
 ## MSVC (System Toolchain, Windows)
 
 MSVC is different from every other toolchain mcpp manages: it is a **system

src/doctor.cppm

@@ -147,6 +147,31 @@ export int doctor_report() {
             if (!any)
                 ok("mingw not installed (optional — `mcpp toolchain install mingw 16.1.0`)");
         }
+
+        // The other direction: a windows-hosted cross toolchain that produces
+        // Linux ELF. Same shape as the mingw probe above; the package is named
+        // by triple, matching to_xim_package()'s `<triple>-gcc`.
+        {
+            auto triple = std::string(mcpp::platform::host_arch) + "-linux-musl";
+            auto label  = std::format("linux cross (xim:{}-gcc)", triple);
+            mcpp::ui::status("Checking", label);
+            auto pkgs = mcpp::home::root() / "registry" / "data" / "xpkgs"
+                      / std::format("xim-x-{}-gcc", triple);
+            std::error_code ec;
+            bool any = false;
+            if (std::filesystem::exists(pkgs, ec)) {
+                for (auto& v : std::filesystem::directory_iterator(pkgs, ec)) {
+                    if (!v.is_directory(ec)) continue;
+                    ok(std::format("{} {} installed",
+                                   triple, v.path().filename().string()));
+                    any = true;
+                }
+            }
+            if (!any)
+                ok(std::format("{} not installed (optional — "
+                               "`mcpp toolchain install gcc 16.1.0 --target {}`)",
+                               triple, triple));
+        }
     }
 
     mcpp::ui::status("Checking", "std module");