[INFRA] Import NVIDIA/CCCL upstream as optimization reference library

CCCL (CUDA C++ Core Libraries) provides:
- CUB: device/block/warp-level GPU primitives (reduce, scan, sort, topk)
- Thrust: high-level parallel algorithms (transform_reduce, sort, scan)
- libcudacxx: CUDA C++ standard library (atomics, barriers, memory)
- cudax: experimental features (memory resources, allocators)
- Tuning policies: per-SM hardware-specific algorithm parameters

Competition optimization vectors mapped to CCCL:
- Output TPS (83% weight): warp_reduce, block_reduce, device_topk
- Input TPS (14% weight): device_scan, block_load, prefetch
- Cache TPS (3% weight): prefix caching strategy patterns
- Memory (0.9 util): pooled/cached/buddy allocators

Source: https://github.com/NVIDIA/cccl (shallow clone, HEAD only)
License: Apache-2.0

cccl_upstream/thrust/examples/weld_vertices.cu

@@ -0,0 +1,84 @@
+#include <thrust/binary_search.h>
+#include <thrust/device_vector.h>
+#include <thrust/host_vector.h>
+#include <thrust/remove.h>
+#include <thrust/sort.h>
+#include <thrust/unique.h>
+
+#include <iostream>
+
+/*
+ * This example "welds" triangle vertices together by taking as
+ * input "triangle soup" and eliminating redundant vertex positions
+ * and shared edges.  A connected mesh is the result.
+ *
+ *
+ * Input: 9 vertices representing a mesh with 3 triangles
+ *
+ *  Mesh              Vertices
+ *    ------           (2)      (5)--(4)    (8)
+ *    | \ 2| \          | \       \   |      | \
+ *    |  \ |  \   <->   |  \       \  |      |  \
+ *    | 0 \| 1 \        |   \       \ |      |   \
+ *    -----------      (0)--(1)      (3)    (6)--(7)
+ *
+ *   (vertex 1 equals vertex 3, vertex 2 equals vertex 5, ...)
+ *
+ * Output: mesh representation with 5 vertices and 9 indices
+ *
+ *  Vertices            Indices
+ *   (1)--(3)            [(0,2,1),
+ *    | \  | \            (2,3,1),
+ *    |  \ |  \           (2,4,3)]
+ *    |   \|   \
+ *   (0)--(2)--(4)
+ */
+
+// define a 2d float vector
+using vec2 = cuda::std::tuple<float, float>;
+
+int main()
+{
+  // allocate memory for input mesh representation
+  thrust::device_vector<vec2> input(9);
+
+  thrust::host_vector<vec2> h_input{
+    vec2(0, 0),
+    vec2(1, 0),
+    vec2(0, 1), // First Triangle
+    vec2(1, 0),
+    vec2(1, 1),
+    vec2(0, 1), // Second Triangle
+    vec2(1, 0),
+    vec2(2, 0),
+    vec2(1, 1) // Third Triangle
+  };
+  input = h_input;
+
+  // allocate space for output mesh representation
+  thrust::device_vector<vec2> vertices = input;
+  thrust::device_vector<unsigned int> indices(input.size());
+
+  // sort vertices to bring duplicates together
+  thrust::sort(vertices.begin(), vertices.end());
+
+  // find unique vertices and erase redundancies
+  vertices.erase(thrust::unique(vertices.begin(), vertices.end()), vertices.end());
+
+  // find index of each input vertex in the list of unique vertices
+  thrust::lower_bound(vertices.begin(), vertices.end(), input.begin(), input.end(), indices.begin());
+
+  // print output mesh representation
+  std::cout << "Output Representation" << '\n';
+  for (size_t i = 0; i < vertices.size(); i++)
+  {
+    vec2 v = vertices[i];
+    std::cout << " vertices[" << i << "] = (" << cuda::std::get<0>(v) << "," << cuda::std::get<1>(v) << ")" << '\n';
+  }
+  for (size_t i = 0; i < indices.size(); i++)
+  {
+    std::cout << " indices[" << i << "] = " << indices[i] << '\n';
+  }
+
+  return 0;
+}