The first form grepped the build log, and the build log carries the ENGINE's
compile lines -- which do name the ecosystem glibc. So it passed for a rule
whose device compile named nothing, and removing the fix it was written for
left it green. Verified, which is the only reason it is not still that shape.

Two things it now gets right:

  * THE OBJECT. An implicit include search never appears on a command line, and
    the log mixes compiles from different compilers. `tools/check_device_c_library.sh`
    extracts the device compile's own C-library flags from build.ninja, asks
    that compiler to print its `#include <...>` search list, and reads the
    order.
  * THE PATTERN. "Any ecosystem path" matched dpcpp's own `include/`, because a
    compiler's resource directory lives in the store too. It now matches what
    actually provides `features.h`: the glibc payload, or a sysroot's
    `usr/include` beneath the registry.

Two admissible answers, both the same property from either side: the rule names
the C library, or the compiler it drives already knows it. Refused is a device
compile that reaches a host path with no ecosystem C library above it.

Measured across all three fixtures -- cuda at position 4, hip at 4, sycl at 2,
first host path at 8, 8 and 6 -- and verified to FAIL for sycl with the fix
removed.

…roject does

not choose its version

The first form asked for `"xim:glibc" = "2.44"`, and CI refused the fixture that
declared exactly that: the runner's runtime binding had chosen glibc 2.44.2.
`xpkg_dir` with a pin answers for that version or for nothing, so the rule told
a project to declare something it had already declared.

The C library version is the RUNTIME BINDING's choice. `""` -- present, any
version -- is the only thing a project can truthfully say about a library it
does not select, and it resolves to whatever the binding installed. Measured:
`"xim:glibc" = ""` answers `…/xim-x-glibc/2.44.2` on the machine that has 2.44.2
in its store.

This is the same shape as the defect the round found in mcpp itself: a value
that belongs to one layer being spelled by another.

It read whatever `build.ninja` sorted first under a fixture's target, which is
a guess about what a previous step left. The fixture steps in CI end with
`build --no-accel`, whose graph has no device action at all, so the check
reported "declares no action to inspect" for three fixtures that were correct.

Two changes, both removing a guess:

  * it runs the accel build itself, because that build is what it is about;
  * it selects the graph that CONTAINS `rule mcpp_action_`, rather than the one
    that sorts first.

It also prints which build.ninja it read, so a future disagreement names its
object instead of being inferred.

Fourth time in this round that a check chose its own object and chose wrong,
and the shape is identical every time: a path or a file picked by convention
rather than by the property being measured.

Verified against the CI shape locally -- accel build followed by `--no-accel`,
then the check -- and still FAILS for sycl with the fix removed.

Carrying the rule's language machinery into the probe was a mistake with a
silent shape: the CUDA and HIP commands begin with `-x cuda`, the probe added
its own `-x c++`, and a compiler given two of them prints no search list at
all. The check reported that as a defect in three fixtures, two of which were
correct.

Where `features.h` comes from does not depend on the language being compiled,
so the probe no longer names one. It keeps `--sysroot=`, `--gcc-install-dir=`
and `-isystem` -- the flags that move the C library -- and asks in plain C++.

It also reads the compiler's stderr, because `-v` writes the search list there,
and prints what the compiler said when there is still nothing to read. The
previous form could only say "printed no search list", which is a description
of the check rather than of the problem.

Measured: cuda 4/7, hip 4/7, sycl 2/8 (ecosystem C library position, first host
path), and still FAILS for sycl with the rule's fix removed.