[CCCL] Add missing CCCL components: c2h, nvbench_helper, cmake, cudax, AGENTS.md

Added 863 files from NVIDIA/cccl sparse checkout:
- c2h/ (27 files): Catch2 test helpers — generators, validators, runner
- nvbench_helper/ (10 files): Benchmark harness utilities
- cmake/ (29 files): CMake presets and build helpers
- cudax/ (794 files): Experimental CUDA extensions
- AGENTS.md: NVIDIA's official AI agent instructions for CCCL
- CMakePresets.json: Standardized build configurations
- cccl-version.json: Version tracking

Also added CCCL_ASSET_MAP.md mapping all 4295 CCCL files to
competition value and PRD items.

cccl_upstream now covers 100% of competition-critical assets:
- 27 tuning headers (SM80/90/100 benchmark data)
- 32 dispatch headers (algorithm implementations)
- 60 Thrust examples (correctness verification)
- 217 CUB Catch2 tests (regression matrix)
- 153 CUB benchmarks (parameter space search)
- 18 CUB examples (API verification)
- 27 test helpers + benchmark harness
- 794 cudax experimental extensions

cccl_upstream/cmake/header_test.cu.in

@@ -0,0 +1,89 @@
+// This source file checks that:
+// 1) Header <@header@> compiles without error.
+// 2) Common macro collisions with platform/system headers are avoided.
+// 3) half/bf16 aren't included when these are explicitly disabled.
+
+// Define CCCL_HEADER_MACRO_CHECK(macro, header), which emits a diagnostic indicating
+// a potential macro collision and halts.
+//
+// Hacky way to build a string, but it works on all tested platforms.
+#define CCCL_HEADER_MACRO_CHECK(MACRO, HEADER) \
+  CCCL_HEADER_MACRO_CHECK_IMPL(                \
+    Identifier MACRO should not be used from Thrust headers due to conflicts with HEADER macros.)
+
+// Use raw platform macros instead of the CCCL macros since we
+// don't want to #include any headers other than the one being tested.
+//
+// This is only implemented for MSVC/GCC/Clang.
+#if defined(_MSC_VER) // MSVC
+
+// Fake up an error for MSVC
+#  define CCCL_HEADER_MACRO_CHECK_IMPL(msg)                                                  \
+    /* Print message that looks like an error: */                                            \
+    __pragma(message(__FILE__ ":" CCCL_HEADER_MACRO_CHECK_IMPL0(__LINE__) ": error: " #msg)) \
+                                                                                             \
+      static_assert(false, #msg); /* abort compilation due to static_assert or syntax error */
+#  define CCCL_HEADER_MACRO_CHECK_IMPL0(x) CCCL_HEADER_MACRO_CHECK_IMPL1(x)
+#  define CCCL_HEADER_MACRO_CHECK_IMPL1(x) #x
+
+#elif defined(__clang__) || defined(__GNUC__)
+
+// GCC/clang are easy:
+#  define CCCL_HEADER_MACRO_CHECK_IMPL(msg)   CCCL_HEADER_MACRO_CHECK_IMPL0(GCC error #msg)
+#  define CCCL_HEADER_MACRO_CHECK_IMPL0(expr) _Pragma(#expr)
+
+#endif // msvc vs. the world
+
+// May be defined to skip macro check for certain configurations.
+#ifndef CCCL_IGNORE_HEADER_MACRO_CHECKS
+
+// complex.h conflicts
+#  define I CCCL_HEADER_MACRO_CHECK('I', complex.h)
+
+// windows.h conflicts
+#  define small CCCL_HEADER_MACRO_CHECK('small', windows.h)
+// We can't enable these checks without breaking some builds -- some standard
+// library implementations unconditionally `#undef` these macros, which then
+// causes random failures later.
+// Leaving these commented out as a warning: Here be dragons.
+// #define min(...) CCCL_HEADER_MACRO_CHECK('min', windows.h)
+// #define max(...) CCCL_HEADER_MACRO_CHECK('max', windows.h)
+
+#  ifdef _WIN32
+// On Windows, make sure any include of Windows.h (e.g. via NVTX) does not define the checked macros
+#    define WIN32_LEAN_AND_MEAN
+#  endif // _WIN32
+
+// termios.h conflicts (NVIDIA/thrust#1547)
+#  define B0 CCCL_HEADER_MACRO_CHECK("B0", termios.h)
+
+#endif // CCCL_IGNORE_HEADER_MACRO_CHECKS
+
+#include <@header@>
+
+#if defined(CCCL_DISABLE_NVFP8_SUPPORT)
+#  if defined(__CUDA_FP8_TYPES_EXIST__)
+#    error We should not include cuda_fp8.h when FP8 support is disabled
+#  endif // __CUDA_FP16_TYPES_EXIST__
+#endif // CCCL_DISABLE_BF16_SUPPORT
+
+#if defined(CCCL_DISABLE_BF16_SUPPORT)
+#  if defined(__CUDA_BF16_TYPES_EXIST__)
+#    error We should not include cuda_bf16.h when BF16 support is disabled
+#  endif // __CUDA_BF16_TYPES_EXIST__
+#  if defined(__CUDA_FP8_TYPES_EXIST__)
+#    error We should not include cuda_fp8.h when BF16 support is disabled
+#  endif // __CUDA_FP16_TYPES_EXIST__
+#endif // CCCL_DISABLE_BF16_SUPPORT
+
+#if defined(CCCL_DISABLE_FP16_SUPPORT)
+#  if defined(__CUDA_FP8_TYPES_EXIST__)
+#    error We should not include cuda_fp8.h when half support is disabled
+#  endif // __CUDA_FP16_TYPES_EXIST__
+#  if defined(__CUDA_FP16_TYPES_EXIST__)
+#    error We should not include cuda_fp16.h when half support is disabled
+#  endif // __CUDA_FP16_TYPES_EXIST__
+#  if defined(__CUDA_BF16_TYPES_EXIST__)
+#    error We should not include cuda_bf16.h when half support is disabled
+#  endif // __CUDA_BF16_TYPES_EXIST__
+#endif // CCCL_DISABLE_FP16_SUPPORT