fix(build.mcpp): reference the std BMI through the token helper too

cl answered "C2230: could not find module 'std'" because the std reference
was still built by string concatenation, producing one argv element with a
space inside it. bmi_reference_tokens existed for exactly this and was only
applied to the bundled mcpp module.

Same shape for the third time — a table entry written for the ninja STRING
channel concatenated into an argv element — so it now has a test that covers
every family and both spellings, plus one for the language-force tokens. The
compiler's own diagnostics name neither the flag nor the reason, which is why
this kept costing a CI round each time.

Author: Sunrisepeak

src/build/build_program.cppm

@@ -628,15 +628,19 @@ std::expected<void, std::string> run_build_program(
             if (!usesModule) stdFlags.push_back("-fmodules");
             stdStagedInBdir = true;
         } else {
-            stdFlags.push_back(std::string(traits.stdBmiUsePrefix)
-                               + sm->bmiPath.string());
+            // Through bmi_reference_tokens, not string concatenation: the
+            // traits spell these for the ninja STRING channel, where
+            // `-fmodule-file=std=<p>` (one word) and `/reference std=<p>`
+            // (two) are indistinguishable. Concatenating produced a single
+            // argv element with a space inside it, and cl answered
+            // "C2230: could not find module 'std'".
+            for (auto& t : mcpp::toolchain::bmi_reference_tokens(
+                     traits.stdBmiUsePrefix, sm->bmiPath))
+                stdFlags.push_back(t);
             if (usesStdCompat && !sm->compatBmiPath.empty())
-                stdFlags.push_back(std::string(traits.stdCompatBmiUsePrefix)
-                                   + sm->compatBmiPath.string());
-            // The prefixes carry a leading space for the ninja string channel;
-            // an argv element must not.
-            for (auto& f : stdFlags)
-                if (!f.empty() && f.front() == ' ') f.erase(0, 1);
+                for (auto& t : mcpp::toolchain::bmi_reference_tokens(
+                         traits.stdCompatBmiUsePrefix, sm->compatBmiPath))
+                    stdFlags.push_back(t);
         }
         if (!sm->objectPath.empty() && fs::exists(sm->objectPath))
             stdObjects.push_back(sm->objectPath.string());

tests/unit/test_hostflags.cpp

@@ -146,6 +146,40 @@ TEST(HostFlags, BmiReferenceSplitsOnlyWhenTheSpellingHasASpace) {
     EXPECT_EQ(msvc[1], "std=/tmp/std.ifc");
 }
 
+// The general invariant, checked for every family: an argv element must never
+// contain a space. This bug has now appeared three times in the same shape —
+// `-x c++`, the mcpp module reference, the std reference — each time because
+// a table entry written for the ninja STRING channel was concatenated into an
+// argv element. cl.exe answers with "could not find module 'std'", which
+// names neither the flag nor the reason.
+TEST(HostFlags, BmiReferencesNeverProduceATokenWithASpace) {
+    for (auto id : kFamilies) {
+        auto tc = tc_for(id);
+        auto t = mcpp::toolchain::bmi_traits(tc);
+        for (auto prefix : { t.stdBmiUsePrefix, t.stdCompatBmiUsePrefix }) {
+            for (auto const& tok : mcpp::toolchain::bmi_reference_tokens(
+                     prefix, std::filesystem::path("/tmp/x.bmi"))) {
+                EXPECT_EQ(tok.find(' '), std::string::npos)
+                    << "family " << mcpp::toolchain::dialect_for(tc).id
+                    << " token: " << tok;
+            }
+        }
+    }
+}
+
+// Same invariant for the language-force spelling, which has both a positional
+// and a per-file form.
+TEST(HostFlags, LanguageForceTokensNeverContainASpace) {
+    for (auto const* d : { &mcpp::toolchain::gnu_dialect(),
+                           &mcpp::toolchain::msvc_dialect() }) {
+        for (auto f : d->forceCxxLangArgv)
+            EXPECT_EQ(f.find(' '), std::string_view::npos) << d->id << ": " << f;
+        for (auto f : d->alwaysFlagsArgv)
+            EXPECT_EQ(f.find(' '), std::string_view::npos) << d->id << ": " << f;
+        EXPECT_EQ(d->perFileCxxPrefix.find(' '), std::string_view::npos) << d->id;
+    }
+}
+
 TEST(HostFlags, BmiReferenceIsEmptyForAToolchainThatNamesNothing) {
     // GCC finds BMIs implicitly under <cwd>/gcm.cache — its prefix is empty
     // and must not produce a stray token.