feat(cccl): integrate missing CCCL directories — python/, ci/, .agent/, docs/, test/

Sparse-checkout from NVIDIA/cccl main branch to complete cccl_upstream:

Added:
- python/cuda_cccl/ (226 files) — Python bindings for device-level algorithms
  Critical for muh toolchain: cuda.compute.reduce_into, scan, radix_sort, etc.
  Includes 204 .py files with full test coverage for all 27 algorithms
- ci/ (163 files) — Build/test infrastructure
  build_cub.sh, test_cub.sh, build_and_test_targets.sh, matrix.yaml
  Directly maps to our [INFRA-CI] and [INFRA-BUILD] items
- .agent/skills/ (7 files) — NVIDIA's own agent skills for CCCL
  cccl-style/SKILL.md, cccl-test/SKILL.md, sass-diff/SKILL.md
- docs/ (491 files) — Official CCCL documentation
  CI references, CMake guides, Python compute docs, libcudacxx PTX docs
- test/ (12 files) — Top-level integration tests (cuda_smoke, stdpar)
- Root configs: .clang-format, .clang-tidy, CONTRIBUTING.md, pyproject.toml
- CLAUDE.md symlink → AGENTS.md (NVIDIA's standard)

cccl_upstream now mirrors full NVIDIA/cccl structure:
  Before: 42M (cub + thrust + libcudacxx + cudax + c + examples + benchmarks)
  After:  53M (+python +ci +docs +.agent +test +configs)

This completes the CCCL base needed for:
- [muh-bench] items: ci/util/build_and_test_targets.sh for targeted builds
- [CCCL-verify] items: python/cuda_cccl/tests/ as reference implementations
- [CCCL-test] items: ci/test_cub.sh, ci/test_thrust.sh
- Agent workflow: .agent/skills/ for consistent style and test patterns

cccl_upstream/docs/libcudacxx/standard_api/utility_library/bitset.rst

@@ -0,0 +1,14 @@
+.. _libcudacxx-standard-api-utility-bitset:
+
+``<cuda/std/bitset>``
+======================
+
+Extensions
+----------
+
+-  All features of ``<bitset>`` are made constexpr in C++14 onwards
+
+Restrictions
+------------
+
+-  On device no exceptions are thrown in case of a bad access.

cccl_upstream/docs/libcudacxx/standard_api/utility_library/expected.rst

@@ -0,0 +1,16 @@
+.. _libcudacxx-standard-api-utility-expected:
+
+<cuda/std/expected>
+=======================
+
+See the documentation of the standard header `\<expected\> <https://en.cppreference.com/w/cpp/header/expected>`_
+
+Extensions
+----------
+
+-  All features are available from C++14 onwards.
+
+Restrictions
+------------
+
+-  On device no exceptions are thrown in case of a bad access.

cccl_upstream/docs/libcudacxx/standard_api/utility_library/functional.rst

@@ -0,0 +1,52 @@
+.. _libcudacxx-standard-api-utility-functional:
+
+<cuda/std/functional>
+=========================
+
+See the documentation of the standard header `\<functional\> <https://en.cppreference.com/w/cpp/header/functional>`_
+
+Omissions
+---------
+
+The following facilities in section
+`functional.syn <https://eel.is/c++draft/functional.syn>`_ of ISO/IEC
+IS 14882 (the C++ Standard) are not available in the NVIDIA C++ Standard
+Library today:
+
+-  `std::function <https://en.cppreference.com/w/cpp/utility/functional/function>`_
+   - Polymorphic function object wrapper.
+-  `std::bind <https://en.cppreference.com/w/cpp/utility/functional/bind>`_
+   - Generic function object binder / lambda facility.
+-  `std::hash <https://en.cppreference.com/w/cpp/utility/hash>`_
+   - Hash function object.
+
+std::function
+~~~~~~~~~~~~~~~~~
+
+`std::function <https://en.cppreference.com/w/cpp/utility/functional/function>`_
+is a polymorphic function object wrapper. Implementing it requires both
+polymorphism (either hand built dispatch tables or the use of C++
+virtual functions) and memory allocation. This means that it is
+non-trivial to implement a heterogeneous version of this facility today.
+As such, we have deferred it.
+
+std::bind
+~~~~~~~~~~~~~
+
+`std::bind <https://en.cppreference.com/w/cpp/utility/functional/bind>`_
+is a general-purpose function object binder / lambda facility. It relies
+on constexpr global variables for placeholders, which presents
+heterogeneous implementation challenges today due to how global
+variables work in NVCC. E.g. We cannot easily ensure the placeholders
+are the same object with the same address in host and device code.
+Therefore, we've decided to hold off on providing this feature for now.
+
+std::hash
+~~~~~~~~~~~~~
+
+`std::hash <https://en.cppreference.com/w/cpp/utility/hash>`_ is a
+function object which hashes entities. While this is an important
+feature, it is also important that we pick a hash implementation that
+makes sense for GPUs. That implementation might be different from the
+default that the upstream libc++ uses. Further research and
+investigation is required before we can provide this feature.

cccl_upstream/docs/libcudacxx/standard_api/utility_library/memory.rst

@@ -0,0 +1,25 @@
+.. _libcudacxx-standard-api-utility-memory:
+
+<cuda/std/memory>
+===================
+
+Provided functionalities
+------------------------
+
+- ``cuda::std::addressof``. See the C++ documentation of `std::addressof <https://en.cppreference.com/w/cpp/memory/addressof>`_
+- ``cuda::std::align``. See the C++ documentation of `std::align <https://en.cppreference.com/w/cpp/memory/align>`_
+- ``cuda::std::assume_aligned``. See the C++ documentation of `std::assume_aligned <https://en.cppreference.com/w/cpp/memory/assume_aligned>`_
+- Uninitialized memory algorithms. See the C++ documentation `<https://en.cppreference.com/w/cpp/memory>`_
+
+Extensions
+----------
+
+-  Most features are available from C++11 onwards.
+-  ``cuda::std::addressof`` is constexpr from C++11 on if compiler support is available
+-  ``cuda::std::assume_aligned`` is constexpr from C++14 on
+
+Restrictions
+------------
+
+- `construct_at` and is only available in C++20 as that is explicitly mentioned in the standard
+- The specialized memory algorithms are not parallel

cccl_upstream/docs/libcudacxx/standard_api/utility_library/optional.rst

@@ -0,0 +1,17 @@
+.. _libcudacxx-standard-api-utility-optional:
+
+<cuda/std/optional>
+=======================
+
+See the documentation of the standard header `\<optional\> <https://en.cppreference.com/w/cpp/header/optional>`_
+
+Extensions
+----------
+
+- All features are available from C++14 onwards.
+- All features are available at compile time if the value type supports it.
+
+Restrictions
+------------
+
+-  On device no exceptions are thrown in case of a bad access.

cccl_upstream/docs/libcudacxx/standard_api/utility_library/tuple.rst

@@ -0,0 +1,17 @@
+.. _libcudacxx-standard-api-utility-tuple:
+
+<cuda/std/tuple>
+====================
+
+See the documentation of the standard header `\<tuple\> <https://en.cppreference.com/w/cpp/header/tuple>`_
+
+Restrictions
+------------
+
+Before version 1.4.0, ``tuple`` is not available when using NVCC with
+MSVC as a host compiler, due to compiler bugs.
+
+Before version 2.3.0 internal compiler errors may be encountered when
+using ``tuple`` with older updates of MSVC 2017 and MSVC 2019. For MSVC
+2017, please use version 15.8 or later (``_MSC_VER >= 1915``). For MSVC
+2019, please use version 16.6 or later (``_MSC_VER >= 1926``).

cccl_upstream/docs/libcudacxx/standard_api/utility_library/type_traits.rst

@@ -0,0 +1,11 @@
+.. _libcudacxx-standard-api-utility-type-traits:
+
+<cuda/std/type_traits>
+=======================
+
+See the documentation of the standard header `\<type_traits\> <https://en.cppreference.com/w/cpp/header/type_traits>`_
+
+Extensions
+----------
+
+-  Most type traits are made available in C++11.

cccl_upstream/docs/libcudacxx/standard_api/utility_library/utility.rst

@@ -0,0 +1,21 @@
+.. _libcudacxx-standard-api-utility-utility:
+
+<cuda/std/utility>
+======================
+
+See the documentation of the standard header `\<utility\> <https://en.cppreference.com/w/cpp/header/utility>`_
+
+Extensions
+----------
+
+- ``pair`` has been made ``trivially_copyable`` in 2.3.0
+
+Omissions
+---------
+
+Prior to version 2.3.0 only ``pair`` is available.
+
+Since 2.3.0 we have implemented almost all functionality of
+``<utility>``. Notably support for operator spaceship is missing due to
+the specification relying on ``std`` types that are not accessible on
+device.

cccl_upstream/docs/libcudacxx/standard_api/utility_library/variant.rst

@@ -0,0 +1,24 @@
+.. _libcudacxx-standard-api-utility-variant:
+
+<cuda/std/variant>
+======================
+
+See the documentation of the standard header `\<variant\> <https://en.cppreference.com/w/cpp/header/variant>`_
+
+Extensions
+----------
+
+-  All features are available from C++14 onwards.
+-  All features are available at compile time if the different value types support it.
+
+Restrictions
+------------
+
+-  On device no exceptions are thrown in case of a bad access.
+
+Cuda specific changes
+---------------------
+
+-  ``cuda::std::visit`` utilizes recursion instead of the usual function
+   pointer array. This greatly improves runtime behavior, but comes at
+   the cost of increased compile times.