tests: link $(VK_OBJ) into the rest of the engine-including rules

[Kenneth-Javier]

Summary

Follow-up to #1728. Under VK=1, 13 rules on current dev (4e28e39) still compile a source with COLI_VULKAN hooks without linking backend_vulkan.o, so they stop at link on the coli_vk_* symbols (26 distinct on Linux).

• Four test-c gates that arrived in pull requests merged shortly after tests: link backend_vulkan.o into the engine-including tests under VK=1 #1728: test_xdna_qt_state and test_xdna_failure (feat(xdna): optional explicit AMD XDNA2 lane for the GLM shared expert #1261), test_logprob_status and test_ablate_mode (feat(engine): replace the ablation scoring mode with a checked, digest-bound one #1356). make -k test-c VK=1 fails on all four on Windows. On Linux the three portable ones fail the same way; test_xdna_failure is Windows-only.
• Nine on-demand rules that test-c never builds, so no test-c run can report them: the benches bench_topp, bench_dsa_select, bench_router_select, bench_idot, bench_i4p_gidot, bench_gemv_stream and bench_mla_simd, plus xdna_physical_probe and test_e8x4g64_loader. The loader test includes colibri.c although its rule does not list it, so a scan of prerequisites cannot see it.

Fix. Each rule lists $(VK_OBJ) as a prerequisite and links it right after $< (after backend_xdna.c in the three XDNA rules), the #1728 pattern. $(VK_OBJ) is empty unless VK=1, so default builds are unchanged.

Guard. c/tests/test_makefile_vk_obj.py keeps this from drifting again; it is what found the nine. Whether a link needs the backend is a preprocessor question, not a textual one: code can pick CUDA over Vulkan with #elif, a hook can be an #ifdef that only reads an environment variable, and a test can define the coli_vk_* functions itself to fake the device (all three occur in #1338). So the test reads no #if lines. It asks the tools:

• make -Bn VK=1 gives every expanded link line (recipe continuations folded), including rules that write a differently named file;
• each .c on a line is preprocessed with that line's own flags (link-only and -MMD/-MF arguments dropped);
• the line needs $(VK_OBJ) when this tree's surviving code, outside backend_vulkan.h, calls a function backend_vulkan.h declares and does not define it; the rule must then link it and list it as a prerequisite;
• the engines whose own source calls the backend anchor a second test, so a broken dry run or preprocess cannot pass silently.

Nothing is hand-listed: the rules come from the Makefile, the API from backend_vulkan.h. A line the host cannot preprocess (bench_idot without ARCH=native on Windows) is left to the platforms that can build it, and .build-config is restored afterwards so the dry run does not make the next real build relink. It needs make (GNU Make 3.81 is enough: $(EXE) comes from make -pn, not --eval) and the Makefile's $(CC), and takes about 20 s. A first, text-only version (the first commit) was exact on dev but flagged 25 rules with #1338 merged where the linker fails one; the second commit replaces it, and the third makes it run under the macOS runner's make 3.81 and read multi-line recipes, so all 204 link lines are covered.

Against the linker (make -k test-c VK=1 plus the on-demand targets):

• dev: fails with exactly the 13 rules above on Linux (12 on Windows, where bench_idot cannot preprocess).
• With this change: passes; on Linux the 60 link lines it says call the backend are exactly the 60 that link backend_vulkan.o.
• With qwen36: Vulkan expert tier, and staged device-local uploads for cards without Resizable BAR #1338 merged on top: reports only tests/test_qwen36_slot_int8, which is also the only link the linker fails there.

Validation

Windows 11, MSYS2 UCRT64 gcc 16.1.0, make 4.4.1, vulkan-loader 1.4.357.0, shaderc 2026.3. On dev, no VK=1 link succeeds on Windows at all (-lvulkan under -static, fixed separately in #1762), so these runs have that fix applied:

• make -k test-c VK=1: exit 0; all 170 TEST_BINS build and pass (4 link failures without this change).
• The nine on-demand targets link and import vulkan-1.dll (bench_idot with ARCH=native, which its #error requires on any build).
• make check (default build, this change alone on dev, at the second commit): exit 0; 170 C test binaries, 1571 Python tests OK (192 skipped), the new test included.

Windows CUDA_DLL=1 and HIP_DLL=1 hosts (no SDK needed for the host build), make -k test-c plus the nine on-demand targets, VK arms on top of the link fix:

• Without VK=1 the link lines of dev and this change are identical (176 of 176, both flavours).
• With VK=1, on dev 12 of the 13 rules have coli_vk_* among their undefined symbols (300 in total); with this change none do, and the failing set is exactly the one without VK=1: 52 targets that do not link backend_loader.o (undefined coli_cuda_* / ink_cuda_*), plus bench_idot without ARCH=native. Pre-existing, the same shape as the Linux CUDA=1 gap below.

WSL Ubuntu 24.04, gcc 13.3.0, make 4.3, libvulkan-dev 1.3.275.0, glslc 2023.8:

• make -k test-c VK=1: exit 0; all 170 TEST_BINS build and pass. test_xdna_qt_state now contains the 31 coli_vk_* definitions.
• The eight portable on-demand targets link. xdna_physical_probe is a Windows tool; on Linux only GetCurrentProcessId stays undefined.
• The new test fails on dev's Makefile with the 13 rules and passes with this change (about 20 s).

Same WSL box, CUDA 13.4.92 + cuBLAS 13.8.0.4, CUDA_ARCH=portable, build and link only (no NVIDIA GPU), make -k test-c plus the nine on-demand targets, dev against this change:

• CUDA=1: both fail on the same 72 of 175 targets, and the link lines of all 172 linking targets are identical token for token. With VK=1 off, the change does nothing.
• CUDA=1 VK=1: on dev, 12 of the 13 rules have coli_vk_* among their undefined symbols (300 in total; the 13th, test_xdna_failure, is Windows-only). With this change none do, and the failing set is exactly the CUDA=1 one.

Those 72 are pre-existing and not about Vulkan, so this PR leaves them alone: 49 stop on undefined coli_cuda_* (engine-including rules without $(CUDA_OBJ), the same shape as this PR, and all 13 rules here are among them); 19 kimi/olmoe/qwen38/dsv41 tests hit cannot find -lcublas because NOCUDA_LDFLAGS filters out -L$(CUDA_HOME)/lib64 but keeps -lcublasLt -lcublas; and 4 V4 targets stop at backend_cuda_dsv4.o, which needs cuda_profiler_api.h, absent from this toolkit install.

CI on this PR, macOS runner: the new test runs and passes under Apple clang and the runner's make, which is GNU Make 3.81. The second commit's version errored there on make --eval (3.82+), which is what the third commit fixes. The suite went from 1479 run with that one error to 1481 run, OK, with the same 156 skipped, so the two new tests ran rather than skipped. All 29 checks are green.

Not verified: a VK=1 build on macOS / MoltenVK, where #1728 was measured, and METAL=1; anything on an NVIDIA GPU; running the benches or the XDNA probe (built only).

• make -C c check
• CUDA changes were tested with make -C c cuda-test (not applicable)
• Performance claims include hardware, commands, and repeatable measurements (no performance claim)
• Performance claims include a validated experiment manifest with raw evidence (no performance claim)

Compatibility

• The default CPU build remains dependency-free ($(VK_OBJ) is empty unless VK=1)
• No model files, generated binaries, or benchmark artifacts are included

Overlap with #1758. #1758 rewrites these same prerequisite lines, so whichever lands second gets a mechanical conflict: 10 hunks, prerequisite lines only. The resolution is to keep #1758's line and append $(VK_OBJ) (in the XDNA rules, after tests/backend_xdna_lane.o). I tried it on a throwaway merge: this test and #1758's test_makefile_deps both pass, and the new test runs unchanged on #1758's Makefile. I'll resolve it on whichever side lands second. With -MMD -MP in CFLAGS the new test writes no .d file.

Overlap with #1338. It merges cleanly with this PR, and together the new test reports tests/test_qwen36_slot_int8: that rule compiles qwen36_tier.c under VK=1 without $(VK_OBJ) and does fail to link. I'll note it on #1338; whichever lands second will need that one line.