[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/libcudacxx/test/support/is_transparent.h

@@ -0,0 +1,106 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TRANSPARENT_H
+#define TRANSPARENT_H
+
+#include "test_macros.h"
+
+// testing transparent
+
+struct transparent_less
+{
+  template <class T, class U>
+  constexpr auto operator()(T&& t, U&& u) const noexcept(noexcept(std::forward<T>(t) < std::forward<U>(u)))
+    -> decltype(std::forward<T>(t) < std::forward<U>(u))
+  {
+    return std::forward<T>(t) < std::forward<U>(u);
+  }
+  using is_transparent = void; // correct
+};
+
+struct transparent_less_not_referenceable
+{
+  template <class T, class U>
+  constexpr auto operator()(T&& t, U&& u) const noexcept(noexcept(std::forward<T>(t) < std::forward<U>(u)))
+    -> decltype(std::forward<T>(t) < std::forward<U>(u))
+  {
+    return std::forward<T>(t) < std::forward<U>(u);
+  }
+  using is_transparent = void() const&; // it's a type; a weird one, but a type
+};
+
+struct transparent_less_no_type
+{
+  template <class T, class U>
+  constexpr auto operator()(T&& t, U&& u) const noexcept(noexcept(std::forward<T>(t) < std::forward<U>(u)))
+    -> decltype(std::forward<T>(t) < std::forward<U>(u))
+  {
+    return std::forward<T>(t) < std::forward<U>(u);
+  }
+
+private:
+  //    using is_transparent = void;  // error - should exist
+};
+
+struct transparent_less_private
+{
+  template <class T, class U>
+  constexpr auto operator()(T&& t, U&& u) const noexcept(noexcept(std::forward<T>(t) < std::forward<U>(u)))
+    -> decltype(std::forward<T>(t) < std::forward<U>(u))
+  {
+    return std::forward<T>(t) < std::forward<U>(u);
+  }
+
+private:
+  using is_transparent = void; // error - should be accessible
+};
+
+struct transparent_less_not_a_type
+{
+  template <class T, class U>
+  constexpr auto operator()(T&& t, U&& u) const noexcept(noexcept(std::forward<T>(t) < std::forward<U>(u)))
+    -> decltype(std::forward<T>(t) < std::forward<U>(u))
+  {
+    return std::forward<T>(t) < std::forward<U>(u);
+  }
+
+  int is_transparent; // error - should be a type
+};
+
+struct C2Int
+{ // comparable to int
+  C2Int()
+      : i_(0)
+  {}
+  C2Int(int i)
+      : i_(i)
+  {}
+  int get() const
+  {
+    return i_;
+  }
+
+private:
+  int i_;
+};
+
+bool operator<(int rhs, const C2Int& lhs)
+{
+  return rhs < lhs.get();
+}
+bool operator<(const C2Int& rhs, const C2Int& lhs)
+{
+  return rhs.get() < lhs.get();
+}
+bool operator<(const C2Int& rhs, int lhs)
+{
+  return rhs.get() < lhs;
+}
+
+#endif // TRANSPARENT_H