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_k_model.py

@@ -0,0 +1,91 @@
+"""Compile a private native K LDR model from verified Windows synthetic captures.
+
+Requires all 11 extracted layers and 16 captured reconstruction tables. Never
+substitutes synthetic tables, installs into a game, or creates a release archive.
+"""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+
+
+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('--capture', required=True, type=lambda p: Path(p).resolve())
+    parser.add_argument('--output', required=True, type=lambda p: Path(p).resolve())
+    parser.add_argument('--glslang', type=lambda p: Path(p).resolve(), default=repo / '.tools/glslang-16.6.0/bin/glslangValidator.exe')
+    parser.add_argument('--reuse', action='store_true')
+    args = parser.parse_args()
+    if not args.output.is_relative_to((repo / 'build').resolve()):
+        parser.error('private model products must stay under ignored build/')
+    validation = json.loads((args.capture / 'validation.json').read_text())
+    if (validation.get('passed') is not True or validation.get('reconstructionLutCaptured') is not True
+            or validation.get('reconstructionTables') != 16 or validation.get('extractedLayers') != 11
+            or validation.get('numerics') != 'explicit-f16-gains'):
+        parser.error('requires verified complete 11-layer/16-table capture')
+    if set(validation['products']) != {'k.bin', 'k.json', 'lut.bin'}:
+        raise RuntimeError('Unexpected/missing capture products')
+    weights = args.capture / 'weights'
+    for name, expected in validation['products'].items():
+        if sha(weights / name) != expected:
+            raise RuntimeError('Capture product changed: ' + name)
+    if (weights / 'lut.bin').stat().st_size != 16 * 32768:
+        raise RuntimeError('Incomplete reconstruction tables')
+    if sha(args.glslang) != '9643709c02c83e26773f96b6a87f197ab2e84f78be0879ad8fb3619418b5d9ad':
+        raise RuntimeError('Requires pinned glslang 16.6.0')
+    inputs = ['engine/compile_k.py', 'engine/test_k.py', 'engine/layer.comp', 'engine/input_k.comp',
+              'engine/output_k.comp', 'engine/exposure_k.comp', 'engine/normalized_store.glsl']
+    identity = dict(schema=1, preset='K', variant='ldr', numerics='explicit-f16-gains',
+                    captureProducts=validation['products'], glslang=sha(args.glslang),
+                    python=sha(Path(sys.executable)), sources={name:sha(repo / name) for name in inputs},
+                    builder=sha(Path(__file__)))
+    stamp = args.output / 'windows-k-model-cache.json'
+    def products():
+        return {p.name:sha(p) for p in sorted(args.output.iterdir()) if p.is_file() and p.name != stamp.name}
+    if args.output.exists():
+        if not args.reuse:
+            parser.error('use a fresh output directory or --reuse')
+        cached = json.loads(stamp.read_text())
+        if cached['identity'] != identity or cached['products'] != products():
+            raise RuntimeError('K model cache changed; preserve it and use a fresh output directory')
+        print('K_MODEL_CACHE_HIT')
+        return
+    env = {key:value for key,value in os.environ.items() if not key.startswith(('D4R_', 'K_DEFS_'))}
+    env['PYTHONPATH'] = os.pathsep.join(str(repo / name) for name in ('.tools/python/vendor', 'engine', 'kernels/tools'))
+    env['PATH'] = str(args.glslang.parent) + os.pathsep + env['PATH']
+    args.output.mkdir(parents=True)
+    command = [sys.executable, str(repo / 'engine/compile_k.py'), str(weights / 'k'),
+               str(weights / 'lut.bin'), str(args.output), '--ldr']
+    with (args.output / 'compile.log').open('wb') as log:
+        process = subprocess.Popen(command, env=env, stdout=log, stderr=subprocess.STDOUT)
+        try:
+            code = process.wait(timeout=600)
+        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('K compilation timed out; process tree terminated')
+    if code:
+        raise RuntimeError('K compilation failed; inspect compile.log')
+    manifest = json.loads((args.output / 'model.json').read_text())
+    if manifest.get('numerics') != 'explicit-f16-gains' or manifest.get('variant') != 'ldr' or len(manifest['layers']) != 11:
+        raise RuntimeError('Incorrect compiled K model contract')
+    for name, expected in manifest['sha256'].items():
+        if Path(name).name != name or sha(args.output / name) != expected:
+            raise RuntimeError('Compiled model product failed verification')
+    stamp.write_text(json.dumps(dict(identity=identity, products=products(), privateLocalModel=True,
+                                    gpuValidated=False, gameValidated=False, published=False), indent=2) + '\n')
+    print('K_MODEL_BUILT private=1 gpu_validated=0 products=' + str(len(products())))
+
+
+if __name__ == '__main__':
+    main()