fix(test): the host KAT punned its result type, and LP64 made it matter

`run_grind` declared its result `uint64_t` and handed the address to the kernel
as `volatile unsigned long long *`. Those are the same type on Darwin/arm64 and
different types of the same width on LP64 glibc, so on Linux the cast
type-punned; with `#include "rpx.cu"` putting the whole kernel in this
translation unit, GCC 13.3 at -O2 was free under TBAA to assume a write through
`unsigned long long *` could not touch an `unsigned long`, and to keep `result`
in a register across the inlined call.

It did. `run_grind` returned UINT64_MAX for every input, so layer 8's two checks
per vector that expect the SENTINEL passed VACUOUSLY while the two that expect a
found nonce failed. Six rows, at every sha back to the gated base c00342c, on
a target that passes on a clang/arm64 laptop where the two types coincide.

Measured on the box at this sha:
  -O2                        6 FAILURE(S)
  -O2 -fno-strict-aliasing   ALL HOST KAT CHECKS PASS
  -O0                        ALL HOST KAT CHECKS PASS

None of it was ever a statement about the device grind. This file is a HOST
replay of the kernel source through `cuda_host_shim.h` — no nvcc, no cubin, no
device — so the defect was in the harness holding the result, not in the kernel
it tests. The production path re-validates every device nonce with the host
predicate, and the block pins read `host fallbacks 0` throughout.

`crypto/math-cuda/tests/host_kat/` holds exactly one instance of the pattern and
this is it: the shim's `atomicMin` takes `unsigned long long *` as a parameter,
and the kernels' casts there only drop `volatile` from an already-matching type.

Test-only; no production code and no proof bytes move. It also unblocks this
lineage's CI `host-kat` job, which has been failing since the device grind
landed.

(cherry picked from commit 90a38ec)

Author: MauroToscano

crypto/math-cuda/tests/host_kat/rpx_host_kat.cpp

@@ -1097,7 +1097,31 @@ void permute_probe_matches_the_oracle_table() {
 // ---------------------------------------------------------------------------
 uint64_t run_grind(const uint64_t inner[4], uint8_t factor, uint64_t base, uint64_t count) {
     const uint64_t limit = (uint64_t)1 << (64 - factor);
-    uint64_t result = UINT64_MAX;
+    // ⛔⛔ `unsigned long long`, NOT `uint64_t`, AND THAT DIFFERENCE WAS THE BUG.
+    // The kernel takes `volatile unsigned long long *` because that is the type
+    // CUDA's `atomicMin` overload wants, so this object's address is handed out
+    // under it. `uint64_t` is `unsigned long long` on Darwin/arm64 and
+    // `unsigned long` on LP64 glibc — a DIFFERENT type of the same width — so on
+    // Linux the cast type-punned, and with `#include "rpx.cu"` putting the whole
+    // kernel in this translation unit, GCC 13.3 at -O2 was free under TBAA to
+    // assume a write through `unsigned long long *` could not touch an
+    // `unsigned long`, and to keep `result` in a register across the inlined call.
+    //
+    // It did. `run_grind` returned `UINT64_MAX` for every input on the box, so
+    // every check below that expects the SENTINEL passed vacuously while every
+    // check that expects a FOUND nonce failed — six rows, at every sha back to
+    // the gated base `c00342c1f`, while the same source passed on a clang/arm64
+    // laptop where the two types coincide. Measured on the box 2026-09-20:
+    // `-O2` → 6 failures; `-O2 -fno-strict-aliasing` → all pass; `-O0` → all pass.
+    //
+    // ⚠ NONE OF THAT WAS EVER A STATEMENT ABOUT THE DEVICE GRIND. This file is a
+    // HOST replay of the kernel source through `cuda_host_shim.h`; the defect
+    // was in the harness holding the result, not in the kernel it was testing.
+    // ⛔ Do not "tidy" this back to `uint64_t`: matching the pointer type the
+    // kernel is given is what makes the access well-defined, and the box gate
+    // carries a mutation that restores `uint64_t` and requires those six rows
+    // back — so the tidy-up would be caught, loudly, by a red nobody wants again.
+    unsigned long long result = UINT64_MAX;
     CUDA_HOST_SINGLE_THREAD();
     rpx_grind_search(inner, limit, base, count, (volatile unsigned long long *)&result);
     return result;