perf(beacon): precompute the epoch transition off the import path

[MegaRedHand]

Motivation

The first block of every epoch runs process_epoch inline on the chain actor (fork_choice::on_block, then stf::state_transition, then process_slots), followed by the post-epoch rehash the state-root check needs. In the import replay such blocks take ~1.5 s against ~0.58 s for an ordinary block (measured on the replay).

The transition depends only on the parent, which is known by the end of the previous epoch's last slot, so it can run ahead of time on a blocking worker, off the import path.

Design

Part	Behaviour
Trigger: head	An import leaves a block at the last slot of epoch E as head: precompute (E+1, head_root). Covers a late last-slot block.
Trigger: timer	Three quarters into the last slot of E, derived from the configured slot duration. The once-per-slot tick arms a delayed self-message on last slots only (send_after). Starts a worker only if none is running and the key is not cached. Covers a skipped last slot, where the head is an earlier block.
Gate	Beacon only. Skipped while the sync tracker says syncing, and for a head more than one slot behind the wall clock (the tracker updates once per slot, so a follower replaying history would otherwise precompute every epoch).
Work	spawn_blocking: clone the head state, process_slots to the first slot of E+1, flush pending writes, hash_tree_root so tree-node hashes are memoized, then message the state back. At most one worker in flight; deduped by (epoch, root) through the cache.
Store	CacheKey::CheckpointState { epoch: E+1, root: head_root }. checkpoint_state derives exactly that value for the checkpoint (the checkpoint block's post-state advanced to the epoch's first slot), so attestation targets for E+1 hit it too. A unit test asserts equal hash_tree_root.
Consume	on_block: when the parent's slot is before the block epoch's first slot and the block is at or after it, look up CheckpointState { block_epoch, parent_root }. A hit clones the entry, advances any remaining skipped slots, and applies the block with the new stf::apply_block (the part of state_transition after process_slots; process_slots rejects a target equal to the current slot, so a boundary block cannot go through state_transition).
Miss / race	Today's path, unchanged. A block that arrives while the worker runs imports inline; the late result is stored and unused by that block.

Forks: process_slots performs the fork upgrade at the boundary, so nothing here is fork-specific.

New metrics (documented in docs/metrics.md): lean_beacon_epoch_precompute_lookups_total{result} (epoch-crossing imports only), lean_beacon_epoch_precompute_seconds, lean_beacon_epoch_precompute_started_total{trigger}.

Not in this PR

• Progressive balances (O(1) justification, and a cheaper compute_pulled_up_tip).
• Holding the block when it races the worker (it computes inline instead, so no ordering dependency is added).
• Advancing the head every slot; only epoch boundaries are advanced.

Testing

• ethlambda-storage lib, ethlambda-state-transition lib, ethlambda-blockchain lib, beacon spec suite (mainnet), clippy and cargo check -p ethlambda: see counts below.
• New unit tests: resuming from a precomputed state gives the inline post-state (block on the boundary and with 1 and 3 skipped slots, compared with the block's committed state root); the lookup applies only to epoch-crossing imports; the worker's state equals checkpoint_state's for the same key; trigger decisions as a pure function (head, timer, syncing, stale head, in-flight, already cached) and the three-quarter delay.
• There is no actor-level test: the beacon actor's test harness drives handlers without a Context, so the trigger decision is tested as a pure function instead.
• Not measured: no benchmark was run for this PR.

Results: storage lib 138 passed (1 ignored); state-transition lib 327 passed (16 ignored); blockchain lib 217 passed; beacon spec suite (mainnet) 5734 passed, 4 failed (the 4 expected gossip matched_fixture_cases on the empty gossip dir), 152 ignored; clippy (workspace, and state-transition with beacon-spec-tests) clean; cargo check -p ethlambda clean.