Make lazy hydration pre-8.4-clean, defer closure-bearing state replays, hand out a Closure initializer

Three follow-ups to the lazy-ghost feature:

- Guard the ghost-only helpers (eligibility check, slot-index build,
  const-expr gate) behind PHP_VERSION_ID >= 80400; they were dead code on
  8.2/8.3 and -Werror builds rejected them. Also narrow the slot count
  pass to closure-bearing ids and drop a redundant parameter and a dead
  branch left over from the broader eligibility design.

- Closure-bearing __wakeup/__unserialize nodes become ghosts too: their
  hook runs at the end of their own initialization instead of in the
  global children-first phase-9 sequence. Per-entry validation stays in
  phase 9; the deferred state is recorded before any user code can
  trigger an initializer, only from entries the eager path would actually
  call (first one wins), so mid-call touches on malformed payloads cannot
  run hooks the eager path would not have run.

- The initializer stored on ghosts is now a Closure over the context's
  private hydrate() method (formerly a public __invoke), so
  ReflectionClass::getLazyInitializer() returns a plain Closure, shared
  by all ghosts of one call.

Author: nicolas-grekas

CHANGELOG.md

@@ -10,26 +10,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - On PHP 8.4+, `deepclone_from_array()` now creates object nodes whose
-  payload slots carry a named-closure or const-expr-closure marker as
+  payload slots or replayed `__unserialize` state carry a named-closure or
+  const-expr-closure marker as
   native lazy ghosts: all object identities (back-references, shared `&`
   references, `===`) exist when the call returns, but those nodes' property
   hydration, closure resolution included, is deferred until the engine
   first touches each of them. Resolving closures (fake-closure creation,
   attribute-args re-evaluation) is the measurably expensive part of
   hydration, so deferral is restricted to the nodes that carry them; plain
   value slots hydrate eagerly as before (copy-on-write makes them cheaper
-  to hydrate than to ghost), as do internal classes, `stdClass`,
-  zero-declared-property classes and `__wakeup`/`__unserialize` nodes, all
-  mixing freely with lazy ones. On PHP 8.2/8.3 everything keeps hydrating
-  eagerly. Structural validation and `$allowed_classes` enforcement
-  (including the const-expr-closure gate) remain eager; only value-level
-  resolution errors (e.g. a stale const-expr closure line, a named-closure
-  target that no longer exists) surface at first access instead of inside
+  to hydrate than to ghost), as do internal classes, `stdClass` and
+  zero-declared-property classes, all mixing freely with lazy ones.
+  Closure-bearing `__wakeup`/`__unserialize` nodes defer too: their hook
+  runs at the end of their own initialization instead of in the global
+  children-first replay sequence, while per-entry validation stays inside
+  the call. On PHP 8.2/8.3 everything keeps hydrating eagerly. Structural
+  validation and `$allowed_classes` enforcement (including the
+  const-expr-closure gate) remain eager; only value-level resolution errors
+  (e.g. a stale const-expr closure line, a named-closure target that no
+  longer exists) surface at first access instead of inside
   `deepclone_from_array()`, where the engine reverts the ghost and keeps it
   retryable. The shared hydration state lives in the new internal-only
-  `DeepClone\HydrationContext` class, which
-  `ReflectionClass::getLazyInitializer()` exposes as the initializer;
-  abandoned half-hydrated graphs are reclaimed by the cycle collector. One
+  `DeepClone\HydrationContext` class;
+  `ReflectionClass::getLazyInitializer()` returns a Closure bound to it.
+  Abandoned half-hydrated graphs are reclaimed by the cycle collector. One
   documented deferral residue: type sources for shared `&` references bound
   to typed properties are registered per node as it hydrates, so a write
   through such a reference is only checked against the already-hydrated

README.md

@@ -92,9 +92,10 @@ function deepclone_hydrate(object|string $object_or_class, array $vars = [], int
 `deepclone_from_array()` creates the object nodes that are expensive to
 hydrate as
 [native lazy ghosts](https://www.php.net/manual/en/language.oop5.lazy-objects.php):
-nodes whose payload slots carry a named-closure or (PHP 8.5)
-const-expr-closure marker, since resolving those (fake-closure creation,
-attribute-args re-evaluation) is where hydration time actually goes. Every
+nodes whose payload slots or replayed `__unserialize` state carry a
+named-closure or (PHP 8.5) const-expr-closure marker, since resolving those
+(fake-closure creation, attribute-args re-evaluation) is where hydration
+time actually goes. Every
 object identity exists when the call returns (back-references, shared `&`
 references and `===` behave exactly as for eager nodes), but a ghost's
 property hydration, closure resolution included, is deferred until the
@@ -109,12 +110,17 @@ $clone = deepclone_from_array($payload);
 All other nodes hydrate eagerly: nodes without closure markers (plain value
 slots are cheaper to hydrate than to ghost, since copy-on-write makes them
 refcount bumps), internal classes (and classes inheriting one, `stdClass`
-descendants excepted), `stdClass` itself and other classes without declared
-properties, and nodes replaying `__wakeup`/`__unserialize` (their call
-order is observable and preserved). A graph without closure markers is
-hydrated fully eagerly and carries zero lazy-mode overhead, and on PHP
-older than 8.4 (no native lazy objects) everything hydrates eagerly.
-Mixing lazy and eager nodes in one graph is the normal mode of operation.
+descendants excepted), and `stdClass` itself and other classes without
+declared properties. A graph without closure markers is hydrated fully
+eagerly and carries zero lazy-mode overhead, and on PHP older than 8.4 (no
+native lazy objects) everything hydrates eagerly. Mixing lazy and eager
+nodes in one graph is the normal mode of operation.
+
+Closure-bearing nodes that replay `__wakeup`/`__unserialize` are deferred
+too: their hook runs at the end of their own initialization instead of in
+the global, children-first replay sequence (each entry is still validated
+inside the call; only the hook calls move). State-replaying nodes without
+closure markers keep their eager, ordered replay.
 
 Semantics of deferred nodes (the usual native lazy-object rules):
 
@@ -134,9 +140,10 @@ Semantics of deferred nodes (the usual native lazy-object rules):
   written value violates a pending node's property type, that node's first
   touch throws instead (eager mode rejects such a write at the assignment).
 - The payload and every object of the graph stay pinned in memory until the
-  last ghost initializes or dies; a shared `DeepClone\HydrationContext`
-  object, also returned by `ReflectionClass::getLazyInitializer()`, holds
-  them. Abandoned graphs are reclaimed by the cycle collector.
+  last ghost initializes or dies: `ReflectionClass::getLazyInitializer()`
+  returns a `Closure` bound to a shared internal
+  `DeepClone\HydrationContext` object that holds them. Abandoned graphs are
+  reclaimed by the cycle collector.
 
 Cost model, measured on 20k-node graphs (PHP 8.4, release build): creating
 ghosts instead of resolving closures cuts `deepclone_from_array()` time by