address maintainer feedback on is_replaceable semantics and tests

Signed-off-by: guptapratykshh <pratykshgupta9999@gmail.com>

Author: guptapratykshh

libs/core/type_support/include/hpx/type_support/is_replaceable.hpp

@@ -8,13 +8,14 @@
 
 #include <hpx/config.hpp>
 
+#include <cstddef>
 #include <type_traits>
 
 #include <hpx/type_support/is_trivially_relocatable.hpp>
 
 namespace hpx::experimental {
 
-#if defined(__cpp_lib_trivially_relocatable)
+#if defined(__cpp_lib_is_replaceable)
     HPX_CXX_CORE_EXPORT template <typename T>
     struct is_replaceable : std::is_replaceable<T>
     {

libs/core/type_support/tests/unit/is_replaceable.cpp

@@ -1,4 +1,4 @@
-//  Copyright (c) 2025 Pratyksh Gupta
+//  Copyright (c) 2026 Pratyksh Gupta
 //
 //  SPDX-License-Identifier: BSL-1.0
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -19,11 +19,14 @@ static_assert(is_replaceable_v<int>);
 // Const types are not assignable (thus not replaceable)
 static_assert(!is_replaceable_v<int const>);
 
-// Pointer types are replaceable
+// Pointer types are replaceable if they are not const-qualified themselves.
 static_assert(is_replaceable_v<int*>);
-static_assert(is_replaceable_v<int const*>);    // pointer itself is mutable
-static_assert(
-    !is_replaceable_v<int* const>);    // const pointer is not replaceable
+static_assert(is_replaceable_v<int const*>);
+
+// Pointers follow the same rules as other objects. A pointer is replaceable only
+// if it is not const-qualified itself, as replacement requires assignment.
+// P2786R13 Section 3.2: "const-qualified objects are never replaceable."
+static_assert(!is_replaceable_v<int* const>);
 
 // Function pointers are replaceable
 static_assert(is_replaceable_v<int (*)()>);
@@ -48,6 +51,10 @@ struct trivial_class
 };
 static_assert(is_replaceable_v<trivial_class>);
 
+// Replaceability implies a type can be destroyed and reconstructed.
+// Consequently, a type must be destructible to be replaceable.
+// Per P2786R13, implicit replaceability also requires trivial relocatability,
+// which in turn requires trivial destructibility.
 struct not_destructible
 {
     not_destructible(not_destructible&&);