bench: attach CMake's own detection log when configure fails

The std.cc question is answered, and it closes the last externally-checkable
difference: the runner reports both manifest sources PRESENT.

    bench: std -> .../include/c++/16.1.0/bits/std.cc (present)
    bench: std.compat -> .../bits/std.compat.cc (present)

So for the linux/gcc cmake arm everything I can inspect from outside now agrees
with a machine where the same cmake 4.0.2 and the same gcc 16.1.0 configure,
generate and build: the manifest is there, its sources are there, and the
runner's exact flag shape (`-B<glibc>/lib -L<glibc>/lib`) reproduces here and
works. What remains is inside CMake's own probe.

CMake writes that down — CMakeConfigureLog.yaml — and nobody reads it, because
it lives in a build directory CI deletes with the job. The cmake adapter now
appends its tail to the cell's log ON FAILURE ONLY, so a green run costs nothing
and a red one carries the evidence.

This is the same move that has now named three failures on their first run after
being added (xmake's missing std dependency, bazel's supports_pic, and this
arm's crt1.o becoming a generate error): when a cell cannot be diagnosed from
CI, fix the diagnosis before guessing again. Every guess I made about this one
before the diagnostics existed was wrong.

Author: speak-agent

bench/src/engines/cmake.cppm

@@ -68,7 +68,38 @@ public:
         };
         if (const auto cxx = resolve_cxx(job.compiler); !cxx.empty())
             argv.push_back(std::format("-DCMAKE_CXX_COMPILER={}", cxx));
-        return platform::run(argv, {}, job.log_path, job.timeout_s);
+        auto r = platform::run(argv, {}, job.log_path, job.timeout_s);
+
+        // ── When configure fails, append CMake's OWN detection log ──────────
+        //
+        // CMake's user-facing errors about the standard library are summaries:
+        //
+        //     The "CXX_MODULE_STD" property ... requires that the
+        //     "__CMAKE::CXX23" target exist, but it was not provided by the
+        //     toolchain.  Reason: Only `libstdc++` is supported
+        //
+        // names neither what it looked for nor what it found. Everything
+        // checkable from OUTSIDE has been checked for the linux/gcc arm and it
+        // all agrees with a machine where the same cmake and the same gcc
+        // succeed: the manifest is present on the runner, both sources it names
+        // are present, and the runner's exact flag shape reproduces and works
+        // locally. What is left is inside CMake's own probe, and CMake writes
+        // that down — in CMakeConfigureLog.yaml, which nobody ever reads
+        // because it lives in a build directory that CI deletes with the job.
+        //
+        // Appended to the cell's log ONLY on failure, so a green run costs
+        // nothing and a red one carries its own evidence.
+        if (!r.ok()) {
+            const auto detail = job.build_dir / "CMakeFiles" / "CMakeConfigureLog.yaml";
+            if (const auto tail = platform::tail_of(detail, 120); !tail.empty()) {
+                std::ofstream log(job.log_path, std::ios::app);
+                if (log) {
+                    log << "\n--- CMakeConfigureLog.yaml (last 120 lines) ---\n"
+                        << tail;
+                }
+            }
+        }
+        return r;
     }
 
     platform::RunResult build(const Job& job) const override {