fix(build): decide full-static from the TARGET, not from the build host

`supports_full_static` is a host constant (`is_linux`) describing what THIS
machine's own binaries can be. flags.cppm read it to decide whether the
ARTIFACT gets `-static` — a different question with a different answer the
moment host != target.

On a Linux host the two coincide for every Linux target, which is why this
survived: it is invisible until a non-Linux host cross-compiles to Linux.
There, `-static` was silently dropped and `x86_64-linux-musl` — a target whose
entire reason to exist is a portable, fully static ELF — produced something
else. No error, no warning; the flag just was not there.

The predicate now reads the parsed triple:
  - empty triple  → host target, so the host capability IS the answer
  - PE targets    → false; their `-static` comes from the C++ runtime
                    distribution contract (dist::Format::Pe), and answering
                    true here would make both mechanisms emit it
  - macOS         → false; libSystem must stay dynamic
  - linux         → true, glibc or musl, native or cross
  - unparseable   → fall back to the host answer rather than guess

Every path that works today is bit-for-bit unchanged: on a Linux host every
branch returns exactly what the old constant returned. Only the previously
broken host!=target case changes.

Turns the previous commit's assertions green:
  [==========] 6 tests from 1 test suite ran.
  [  PASSED  ] 6 tests.

Refs .agents/docs/2026-08-03-windows-host-linux-cross-design.md §1.3 (B2)

Author: Sunrisepeak

src/build/flags.cppm

@@ -21,6 +21,7 @@ import mcpp.toolchain.detect;
 import mcpp.toolchain.dialect;
 import mcpp.toolchain.hostflags;
 import mcpp.toolchain.linkmodel;
+import mcpp.toolchain.model;
 import mcpp.toolchain.provider;
 import mcpp.toolchain.registry;
 
@@ -536,7 +537,15 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     // Link flags
     f.staticStdlib = plan.manifest.buildConfig.staticStdlib;
     f.linkage = plan.manifest.buildConfig.linkage;
-    std::string full_static = (mcpp::platform::supports_full_static && f.linkage == "static") ? " -static" : "";
+    // Whether the ARTIFACT can be fully static is a property of the target,
+    // not of this machine. Reading the host constant directly here dropped
+    // `-static` from every Windows→Linux cross build, silently turning the
+    // musl targets into something they are not. The host constant is still
+    // the right answer for a host-target build, so it is threaded in as the
+    // fallback rather than discarded.
+    const bool full_static_ok = mcpp::toolchain::target_supports_full_static(
+        plan.toolchain.targetTriple, mcpp::platform::supports_full_static);
+    std::string full_static = (full_static_ok && f.linkage == "static") ? " -static" : "";
 
     // ---- C++ runtime distribution contract (issue #336) -------------------
     //

src/toolchain/model.cppm

@@ -143,10 +143,28 @@ bool is_mingw_target(const Toolchain& tc) {
 }
 
 bool target_supports_full_static(std::string_view targetTriple, bool hostCapability) {
-    // STUB — deliberately reproduces the pre-fix behaviour so the regression
-    // test added alongside it goes red. Replaced in the next commit.
-    (void)targetTriple;
-    return hostCapability;
+    // Empty triple means "build for this machine" — target IS host, so the
+    // host answer is the correct one. This is the only case where the host
+    // capability legitimately decides.
+    if (targetTriple.empty()) return hostCapability;
+
+    auto t = triple::parse(targetTriple);
+    // Outside the triple language we have nothing to reason from. Fall back
+    // to the host answer rather than guessing from a substring — a wrong
+    // `true` here would emit `-static` at a target that cannot honour it.
+    if (!t) return hostCapability;
+
+    // PE targets get their `-static` from the C++ runtime distribution
+    // contract (dist::Format::Pe in flags.cppm), never from here. Returning
+    // false is what keeps the two mechanisms from both emitting the flag.
+    if (t->is_pe()) return false;
+
+    // macOS cannot fully static-link: libSystem must stay dynamic.
+    if (t->os == "macos") return false;
+
+    // Linux ELF — glibc or musl, native or cross. This is the line that was
+    // previously gated on the HOST being Linux.
+    return t->os == "linux";
 }
 
 BmiTraits bmi_traits(const Toolchain& tc) {