fix(metrics): discard block-processing time for duplicate blocks (#523)

## Problem

`lean_fork_choice_block_processing_time_seconds` is sampled by a
`TimingGuard` created at the top of `on_block_core`, **before** the
idempotent duplicate-block check returns early. A duplicate block does
no processing, so it recorded a near-zero sample that skews the
histogram low. Duplicates are common during range sync, so the effect is
not negligible.

This is the same class of issue as the recently fixed tick-interval
metric (#514): the sample boundary didn't line up with the unit of work
— there it inflated the tail, here it deflates the percentiles.

## Change

- Add `TimingGuard::discard()` to cancel a measurement before the guard
drops (a `disarmed` flag checked in `Drop`).
- Call it on the duplicate-block early return in `on_block_core`.

The block hashing (`hash_tree_root`) stays inside the timed span since
it is real work; only the sample for a no-op duplicate is dropped. All
other early returns (validation rejections) still record, as they
represent real processing time.

## Verification

`make fmt`, `make lint` (clean), full workspace build. Two new unit
tests in `timing.rs` cover the guard: `records_a_sample_on_drop` and
`discard_suppresses_the_sample` (both pass). `cargo test -p
ethlambda-blockchain` 46 unit tests pass. Fork-choice/signature spec
tests require downloaded fixtures (absent in this env).

Author: MegaRedHand

crates/blockchain/src/store.rs

@@ -569,7 +569,7 @@ fn on_block_core(
     signed_block: SignedBlock,
     verify: bool,
 ) -> Result<(), StoreError> {
-    let _timing = metrics::time_fork_choice_block_processing();
+    let timing = metrics::time_fork_choice_block_processing();
     let block_start = std::time::Instant::now();
 
     let block = &signed_block.message;
@@ -581,6 +581,7 @@ fn on_block_core(
         .has_state(&block_root)
         .expect("DB read should succeed")
     {
+        timing.discard();
         return Ok(());
     }
 

crates/common/metrics/src/timing.rs

@@ -5,6 +5,11 @@ use std::time::Instant;
 use crate::Histogram;
 
 /// A guard that records elapsed time to a histogram when dropped.
+///
+/// The measurement can be cancelled with [`TimingGuard::discard`], which
+/// consumes the guard without recording a sample, for a timed path that turns
+/// out to be a no-op whose duration would only skew the histogram (e.g. an
+/// idempotent early return).
 pub struct TimingGuard {
     histogram: &'static Histogram,
     start: Instant,
@@ -17,6 +22,22 @@ impl TimingGuard {
             start: Instant::now(),
         }
     }
+
+    /// Consume the guard without recording a sample.
+    ///
+    /// Use when the timed work should not contribute a sample, such as a
+    /// duplicate/idempotent request that returns early: the elapsed time is
+    /// real but recording it would skew the histogram toward near-zero.
+    ///
+    /// `TimingGuard` implements [`Drop`], so its fields cannot be moved out to
+    /// destructure it directly. Wrapping in [`std::mem::ManuallyDrop`] inhibits
+    /// the recording `Drop`; the fields are `Copy`, so they are then read out
+    /// and their copies dropped here, leaving nothing to record.
+    pub fn discard(self) {
+        let guard = std::mem::ManuallyDrop::new(self);
+        let _histogram = guard.histogram;
+        let _start = guard.start;
+    }
 }
 
 impl Drop for TimingGuard {