tests: cover tiered_cloud capacity-driven local reclaim

Add test_capacity_pressure_reclaims_tiered_cloud: a no-local-target
tiered_cloud topic under a low retention_local_target_capacity_bytes must be
bounded by the disk_space_manager capacity path (grows unbounded without it),
with no do_gc pin-steal warning. Fills the previously-aspirational
disk-pressure coverage in the file.

Signed-off-by: Oren Leiman <oren.leiman@redpanda.com>

Author: oleiman

tests/rptest/tests/tiered_cloud_local_retention_test.py

@@ -299,6 +299,75 @@ def test_local_data_grows_in_tiered_cloud(self):
             f"expected near {replication * self.local_target_bytes} bytes"
         )
 
+    @cluster(num_nodes=4)
+    def test_capacity_pressure_reclaims_tiered_cloud(self):
+        """
+        Cluster-wide disk pressure (the disk_space_manager capacity path)
+        reclaims a tiered_cloud partition's local log, not just the
+        retention.local.target path.
+
+        The topic sets no local target and effectively infinite retention, so
+        only the capacity path can bound it. On a build that excludes
+        tiered_cloud partitions from disk_space_manager the local log grows
+        unbounded and this fails; with them admitted, the eviction policy pins
+        _cloud_gc_offset and ctp_stm trims to it, so the footprint converges
+        near the capacity target.
+
+        Also asserts do_gc leaves the pin for ctp_stm (no "expected remote
+        retention to be active" warning); stealing it would make trimming
+        race-dependent.
+        """
+        assert self.redpanda is not None
+
+        # Node-wide log-data target, small enough that the produced topic must
+        # be trimmed to meet it. disk_reservation_percent=0 and percent=100 so
+        # the bytes target is the effective one.
+        capacity_target = 16 * 1024 * 1024
+        self.redpanda.set_cluster_config(
+            {
+                "retention_local_target_capacity_bytes": capacity_target,
+                "retention_local_target_capacity_percent": 100,
+                "disk_reservation_percent": 0,
+            }
+        )
+
+        # No retention.local.target.bytes: the local-target path stays inert
+        # (only the 1-day default applies, and nothing is that old), so only
+        # the capacity path can bound this topic. retention.bytes is
+        # effectively unlimited, mirroring the field scenario that filled the
+        # disk.
+        rpk = RpkTool(self.redpanda)
+        rpk.create_topic(
+            topic=self.topic_name,
+            partitions=1,
+            replicas=3,
+            config={
+                TopicSpec.PROPERTY_STORAGE_MODE: (TopicSpec.STORAGE_MODE_TIERED_CLOUD),
+                "cleanup.policy": TopicSpec.CLEANUP_DELETE,
+                "retention.bytes": str(self.retention_bytes),
+                "segment.bytes": str(self.segment_size),
+            },
+        )
+        self._wait_for_partition_info()
+
+        # Produce well past the capacity target so an untrimmed build grows far
+        # beyond it.
+        produce_bytes = 64 * 1024 * 1024
+        self._produce(produce_bytes)
+        self.wait_until_reconciled(topic=self.topic_name, partition=0)
+
+        # The target is per node; the metric sums 3 replicas. Allow 3x the
+        # target plus per-replica headroom (the never-evicted active segment,
+        # internal logs, trim-cycle latency). Still far below the ~3x produce an
+        # untrimmed build retains.
+        replication = 3
+        ceiling = replication * (capacity_target + 4 * self.segment_size)
+        self._wait_local_below(ceiling_bytes=ceiling, timeout_sec=180)
+
+        assert not self.redpanda.search_log_any(
+            "expected remote retention to be active"
+        ), "do_gc stole the space-management pin from ctp_stm"
+
     @cluster(num_nodes=4)
     def test_compact_topic_evicts_via_l1_floor(self):
         """