feat(beacon): time the state-writer hand-off as its own import phase

[MegaRedHand]

Motivation

Beacon post-states are persisted by one background thread fed through a bounded queue. StateWriterHandle::send blocks while the queue is full, and Store::insert_state calls it from inside fork_choice::on_block, which the chain actor times as the stf phase. If blocks import faster than the writer persists them, the importer's wait for the writer is reported as state-transition time. This PR reports the wait as its own phase, so stf measures state-transition work only.

Measured on the import-replay benchmark (128 mainnet blocks, eth-5) with this change merged into each leg:

leg	stf p50 (now exclusive)	writer_wait p50	block wall p50
base (beacon-chain-integration)	581 ms	~0	777 ms
each single performance PR (#647-#650, #633)	353-618 ms	~0 (max 4 us)	551-778 ms
all five performance PRs merged	202 ms	326 ms	559 ms

With all five merged, blocks import faster than the writer persists their states, so the queue fills and the importer waits about 326 ms per block. Without this phase that wait was reported as stf (about 530 ms instead of 202 ms), which hid most of the combined gain and pointed at the wrong place. The state writer, not the state transition, is now the replay's bottleneck.

Changes

Area	Change
storage/state_writer.rs	StateWriterHandle::send returns the (start, end) instants around its blocking send
storage/store.rs	insert_state records the hand-off span (first start, last end if repeated) in a shared field; new Store::take_state_handoff() takes and clears it
blockchain/import_timing.rs	writer_wait_start/writer_wait_end on ImportTimings and StoreTimings, copied in absorb_store; new writer_wait row after stf; header documents the nesting
blockchain/lib.rs	Beacon arm takes the hand-off instants right after on_block returns (both Ok and Err); clears any stale span before the call
blockchain/metrics.rs	writer_wait added to BLOCK_IMPORT_PHASES (the phase label list)
docs/metrics.md, docs/benchmarking.md	Phase documented; beacon stf now excludes the wait

The replay benchmark builds its phases map from BLOCK_IMPORT_PHASES and the same histogram, so it picks up writer_wait and the exclusive stf with no code change.

One beacon on_block makes one insert_state call. The store still merges repeated calls (first start, last end), the module's convention for repeated sections.

Semantics change

Beacon stf (the report row and the lean_block_import_phase_seconds{phase="stf"} series) now excludes the writer wait: it is the on_block span minus writer_wait, saturating at zero. The rows still sum to the end-to-end time. Lean blocks never set the new instants, so their stf and report are unchanged. A new phase="writer_wait" series appears on beacon only. Dashboards comparing beacon stf across this change will see it drop by the wait.

Testing

Command	Result
cargo fmt --all	clean
cargo clippy --workspace --all-targets --profile release-fast -- -D warnings	clean
cargo test -p ethlambda-storage --profile release-fast --lib	139 passed, 1 ignored
cargo test -p ethlambda-blockchain --profile release-fast --lib	210 passed, 0 ignored
cargo check -p ethlambda --profile release-fast	clean

New tests: stf minus writer_wait, wait absent, wait longer than stf saturating to zero, row order and presence (existing label-list test also covers the new label), and a storage test that insert_state records a start <= end pair and that taking it clears it. Spec suites and the replay benchmark were not run.

Clippy ran without --locked: Cargo.lock on the base (125dce1) is already stale (zk_alloc is listed under the wrong crate), so --locked fails there with or without this change. The lockfile is not part of this PR.