bench: drop the warm metadata walk from the hydration benchmarks

test_hydration_metadata re-read the cached name, full name, parent and
root of every class in a 20- and a 200-substate tree. It came in with
#7064 to show the per-class metadata cache replacing the lru_cache whose
128-entry capacity the 200-class tree thrashed. With that cache in place
both sizes measure the same cache-hit path, and that path is almost
entirely CPython's type attribute cache and call specialization rather
than reflex code.

That makes it flip on CodSpeed with no related change: [200] alternates
between 1.7 and 1.8 ms (-6.9% on #7502, -7.7% on #7501), [20] between
207.6 and 216.7 us (-4.2% on #7410 and #7434, +4.3% on the changelog-only
#7445), while every other benchmark reports untouched.

Reproduced under callgrind with the same pytest-codspeed instrumentation
CI uses. Two runs of the module alone are byte-identical: 1,420,889 Ir
for [200]. Running test_state_access.py or test_state_delta.py first in
the same process gives 1,363,413 and 1,306,760 Ir (-4.0%, -8.0%) for the
unchanged function, while test_hydration_snapshot[200] moves about 1%
(5,335,449 to 5,392,507). The count depends on what the process did
before the benchmark, not on the code it measures, so no restructuring
of the body would settle it.

test_hydration_snapshot stays: it walks the same metadata on its way to
serializing the tree, so a regression in the metadata path still shows
up there, diluted by real work enough to sit under the threshold when
nothing changed.

The two removed benchmarks show as skipped on CodSpeed until they are
archived in the project settings.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011LZPUJkHZur6LUinHeFpZT

Author: claude

tests/benchmarks/test_state_hydration.py

@@ -1,4 +1,12 @@
-"""Track state-tree hydration costs below and above the metadata LRU capacity."""
+"""Track complete snapshots of small and large state trees.
+
+A snapshot resolves every substate's full name through the per-class metadata
+caches (name and parent) on its way to serializing it, so a regression in those
+caches shows up here too. A separate benchmark that only re-read the cached
+metadata was dropped: with no serialization work to dilute them, CPython's
+attribute-cache and specialization costs dominated, and those move several
+percent with whatever ran earlier in the process.
+"""
 
 import pytest
 from pytest_codspeed import BenchmarkFixture
@@ -42,27 +50,3 @@ def test_hydration_snapshot(
         benchmark: The benchmark fixture.
     """
     benchmark(hydration_state.dict)
-
-
-def test_hydration_metadata(
-    hydration_state: BaseState, benchmark: BenchmarkFixture
-) -> None:
-    """Measure repeated metadata walks without state serialization costs.
-
-    Args:
-        hydration_state: The populated tree whose classes to visit.
-        benchmark: The benchmark fixture.
-    """
-    classes = [
-        type(hydration_state),
-        *(type(s) for s in hydration_state.substates.values()),
-    ]
-
-    @benchmark
-    def walk() -> None:
-        """Visit the metadata used to fetch and reconnect a state tree."""
-        for cls in classes:
-            cls.get_name()
-            cls.get_full_name()
-            cls.get_parent_state()
-            cls.get_root_state()