TL;DR: Add an experimental FSR Ray Regeneration backend on Windows, run the K

network natively on HIP with Vulkan->HIP shared memory, extend K kernels to
gfx11 (RDNA3), and add dependency/packaging/test tooling around them.

Windows: FSR RR backend, native HIP K runner, gfx11 K kernels, tooling

FSR Ray Regeneration (experimental)
- Add fsr_rr_backend.{h,cpp}, fsr_rr_passes.h and the fsr_rr/ prepare and
  compose compute shaders. They run AMD's FidelityFX denoiser
  (amd_fidelityfx_denoiser_dx12.dll, SDK 2.3, not bundled) on a private
  vkd3d-proton device.
- Add the amdxc64 shim (tools/windows/amdxc64_shim) and two vkd3d-proton
  patches for libcxx includes. AMD's amdxc64.dll is never loaded.
- d4r_nvngx_windows: RrFeature now selects between the native DLSS RR
  backend and the FSR backend (D4R_RR_BACKEND=fsr). After the denoiser it
  runs an internal Super Sampling stage (feature 1) to upscale. If SR is
  unavailable and output != render size, the frame fails; it is never
  returned noisy.
- d4r.ini / player_config: new [RayReconstruction] FsrDenoiser,
  FsrStabilityBias (auto or >= 0) and FsrDetail (0-1), with validation, and
  matching D4R_FSR_* environment variables.
- Add the FSR RR fixture, output-check and ngx test scripts, and a shader
  compile script.

Native HIP K runner (Windows)
- CMake: add d4r_engine_k_hip (d4r-k-hip) plus separate volk/engine copies,
  because VK_USE_PLATFORM_WIN32_KHR changes volk's entry points.
- Share Vulkan memory with HIP via Win32 opaque handles on Windows
  (VK_KHR_external_memory_win32) and via fds on Linux. Handle types are now
  intptr_t, and the platform choice is in D4R_EXT_MEMORY_* macros.
- HipNetwork: add debugRepeatHashes and debugNodeMicros, exposed as
  D4R_HIP_REPEAT_CHECK, D4R_HIP_REPEAT_ALL and D4R_HIP_NODE_PROFILE in
  replay.cpp.
- replay.cpp: display-resolution-motion frames (FrameFlagDisplayMotion) no
  longer require near2rnd == out2rnd. Both values must still be in (0, 1].

K kernels on gfx11
- Allow position-token and enc1 tiling on __GFX11__ as well as gfx12.
- Add an opt-in ds_bpermute cross-half exchange
  (D4R_WINDOWS_GFX11_DS_EXCHANGE, enabled for K on Windows gfx11). M keeps
  its LDS path.
- Fix a block-barrier race in the position layer. Without POS_VSHARE a fast
  wave could overwrite its hb rows while a slower wave still read them for a
  later head, giving rare wrong results on gfx1101 (enc0 outputs differing
  between identical launches).

Packaging and install
- install.bat, d4r.ini, WINDOWS_README: FSR option, and
  install_dependencies.py to install pinned NVIDIA dependencies with staged,
  hash-verified replacement and rollback.
- Update the release package, local package refresh and test scripts.
- Add the InteropBatchInputCopies option (default false). Batching is faster
  on some synthetic runs, but player temporal exactness is unresolved.

Tooling and tests
- K model: capture_k_weights, build_k_model, compare_k_outputs,
  benchmark_k_hip, build_capture_runtime, test_k_model and the
  zluda-k-output-capture patch. Captured weights and models are private
  local assets and must not enter release archives.
- Synthetic probes: test_m_ngx, test_sr_dynamic,
  prepare_rr_dynamic_fixture and the d3d12/rr_ngx probe updates.
- Add tests/windows/test_install_dependencies.py.

Docs
- Update the windows-fsr-rr, k-performance, local-package, rr-interop and
  rr-model-cache docs. Add windows-parity-handoff.md and
  windows-parity-continuation-prompt.md.

tools/windows/build_capture_runtime.py

@@ -0,0 +1,95 @@
+"""Build an isolated diagnostic ZLUDA runtime using the already-built LLVM tree.
+
+Never replaces the delivered runtime or rebuilds LLVM. Output is local under
+build/. The copied runtime is for audited synthetic captures, not game use.
+"""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+
+
+def sha(path):
+    with path.open('rb') as stream:
+        return hashlib.file_digest(stream, 'sha256').hexdigest()
+
+
+def main():
+    repo = Path(__file__).resolve().parents[2]
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--runtime', required=True, type=lambda p: Path(p).resolve())
+    parser.add_argument('--output', required=True, type=lambda p: Path(p).resolve())
+    parser.add_argument('--jobs', type=int, default=4)
+    args = parser.parse_args()
+    if args.output.exists() or not args.output.is_relative_to((repo / 'build').resolve()):
+        parser.error('use a fresh directory under ignored build/')
+    if args.output.is_relative_to(args.runtime) or not 1 <= args.jobs <= 8:
+        parser.error('output must be outside input runtime; jobs must be 1..8')
+    source = repo / 'external/ZLUDA'
+    if '"hiluma_engine_output_depthreg_mvhi_ldr_max_v2_rel" => Some(328)' not in (source / 'zluda/src/impl/d4r_replay.rs').read_text():
+        parser.error('apply tools/windows/zluda-k-output-capture.patch to the prepared Windows ZLUDA source first')
+    llvm = repo / 'build/zluda-llvm-windows-gnu'
+    rust = repo / '.tools/rust-1.98.1-gnu'
+    compiler = repo / '.tools/llvm-mingw-20260922-ucrt-x86_64'
+    target = repo / 'build/zluda-rust-windows-gnu'
+    for path in (llvm / 'bin/llvm-config.exe', rust / 'bin/cargo.exe', source / 'ptx/lib/zluda_ptx_impl.bc'):
+        if not path.is_file():
+            parser.error('prebuilt dependency missing: ' + str(path))
+    args.output.mkdir(parents=True)
+    artifact = target / 'x86_64-pc-windows-gnu/release/nvcuda.dll'
+    if artifact.exists():
+        shutil.copy2(artifact, args.output / 'previous-cargo-nvcuda.dll')
+    environment = os.environ.copy()
+    environment.update(CARGO_HOME=str(repo / '.tools/cargo-home'), CARGO_TARGET_DIR=str(target),
+                       CARGO_BUILD_JOBS=str(args.jobs), RUSTC=str(rust / 'bin/rustc.exe'),
+                       CC=str(compiler / 'bin/x86_64-w64-mingw32-clang.exe'),
+                       CXX=str(compiler / 'bin/x86_64-w64-mingw32-clang++.exe'),
+                       AR=str(compiler / 'bin/llvm-ar.exe'), CXXSTDLIB='c++',
+                       LIBRARY_PATH=str(rust / 'lib/rustlib/x86_64-pc-windows-gnu/lib/self-contained'),
+                       CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER=str(compiler / 'bin/x86_64-w64-mingw32-clang.exe'),
+                       CARGO_TARGET_X86_64_PC_WINDOWS_GNU_RUSTFLAGS='-C link-arg=-static',
+                       ZLUDA_LLVM_BUILD_DIR=str(llvm))
+    environment['PATH'] = os.pathsep.join(str(p) for p in (rust / 'bin', compiler / 'bin',
+        repo / '.tools/python/cmake/data/bin', repo / '.tools/python/bin', Path('C:/Program Files/Git/usr/bin'))) + os.pathsep + environment['PATH']
+    report = dict(passed=False, diagnosticOnly=True, llvmRebuilt=False, deliveredRuntimeChanged=False,
+                  originalRuntimeSha256=sha(args.runtime / 'zluda/nvcuda.dll'),
+                  captureSourceSha256=sha(source / 'zluda/src/impl/d4r_replay.rs'),
+                  llvmConfigSha256=sha(llvm / 'bin/llvm-config.exe'))
+    try:
+        command = [str(rust / 'bin/cargo.exe'), 'build', '--offline', '--locked', '--release',
+                   '--target', 'x86_64-pc-windows-gnu', '-p', 'zluda']
+        with (args.output / 'cargo.log').open('wb') as log:
+            process = subprocess.Popen(command, cwd=source, env=environment, stdout=log, stderr=subprocess.STDOUT)
+            try:
+                code = process.wait(timeout=1800)
+            except subprocess.TimeoutExpired:
+                subprocess.run(['taskkill', '/PID', str(process.pid), '/T', '/F'], check=False, timeout=30,
+                               stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                process.wait(timeout=30)
+                raise RuntimeError('Capture runtime build timed out; process tree terminated')
+            if code:
+                raise subprocess.CalledProcessError(code, command)
+        runtime = args.output / 'runtime'
+        shutil.copytree(args.runtime, runtime)
+        shutil.copy2(artifact, runtime / 'zluda/nvcuda.dll')
+        for name in ('libc++.dll', 'libunwind.dll'):
+            shutil.copy2(compiler / 'bin' / name, runtime / 'zluda' / name)
+        if sha(args.runtime / 'zluda/nvcuda.dll') != report['originalRuntimeSha256']:
+            raise RuntimeError('Original runtime changed during build')
+        report.update(passed=True, runtime=str(runtime), runtimeSha256=sha(runtime / 'zluda/nvcuda.dll'),
+                      sourceBase=subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=source, text=True).strip(),
+                      sourceWorkingTree='local modified; capture source hash recorded, no clean source assertion',
+                      gpuValidation=False, published=False)
+        print(json.dumps(report, indent=2))
+    except Exception as error:
+        report['error'] = str(error)
+        raise
+    finally:
+        (args.output / 'build.json').write_text(json.dumps(report, indent=2) + '\n')
+
+
+if __name__ == '__main__':
+    main()