fix: decide a build step by its exit code, not by whether it printed

RunCommand merged stderr into stdout, dropped pclose's status and returned
the text; every compile, link and archive site then read "printed something"
as "failed". A warning is printing something, so a translation unit that
warned failed the build — but only on the run that actually recompiled it,
since warnings aren't re-emitted for an object that's already up to date.
The same unchanged source therefore passed or failed depending on the state
of the build tree: flaky-looking tests locally, and a cold CI checkout
surfacing every latent warning in a project at once as unrelated failures.

RunCommand is gone, replaced by RunBuildCommand: it goes through
RunCommandChecked, returns "" when the command exited 0 (so every caller's
`if (!result.empty())` error path is unchanged) and hands any warnings to
the new Progress::Diagnostic instead of to the error path. That also closes
the quiet half of the bug — a compiler killed by the OOM killer prints
nothing, so it used to read as success and leave the build carrying on with
a missing object; it now reports the signal that killed it.

Warnings are now shown rather than swallowed, which they weren't in either
direction before: invisible on an incremental build, fatal on a cold one.
Failing on them stays a project's choice, via -Werror in compileFlags.

implementations/Crafter.Build-Progress.cpp

@@ -127,6 +127,18 @@ void EchoCommand(std::string_view command) {
     }
 }
 
+void Diagnostic(std::string_view text) {
+    std::lock_guard lock(StateMutex);
+    if (ActiveVerbosity == Verbosity::Quiet) return;
+    ClearLineLocked();
+    // Written whole under StateMutex: parallel compiles hand us one warning
+    // block each, and interleaving them line-by-line would make every
+    // "note: ..." continuation follow the wrong diagnostic.
+    std::fwrite(text.data(), 1, text.size(), stderr);
+    if (!text.ends_with('\n')) std::fputc('\n', stderr);
+    std::fflush(stderr);
+}
+
 void Clear() {
     std::lock_guard lock(StateMutex);
     ClearLineLocked();