cl/phase1/forkchoice: fix block_importing_latency never recording on Fulu+

[lystopad]

Problem

block_importing_latency (Caplin) reads a flat 0 for hours in Grafana — it's effectively never recorded.

It's a gauge set only by ObserveBlockImportingLatency, whose only caller (collectOnBlockLatencyToUnixTime) was nested inside the Deneb-only blob data-availability branch of OnBlock, behind:
checkDataAvaiability && BlobKzgCommitments.Len() > 0 && !elHasBlobs && version is Deneb/Electra (not Fulu) && highestSeen < slot.

Two of those gates kill it:

• Fulu+ (current mainnet) takes the Fulu/PeerDAS branch, which never calls it → the gauge stays at its 0 default. This is the flat line.
• Even pre-Fulu it only fired for a current-slot block carrying blobs the EL didn't already have — a rare race at tip — and skipped blob-less blocks entirely.

So the panel value is not a real "0 ms"; the setter just isn't reached.

Fix

Move the single call to the fork-agnostic highestSeen tip-advance in OnBlock, which runs for every new head block on all forks (Fulu/Gloas included). The helper's existing slot == GetCurrentSlot() guard still skips backfill/sync blocks, so the gauge measures head-arrival latency rather than block age.

if block.Block.Slot > f.highestSeen.Load() {
    f.highestSeen.Store(block.Block.Slot)
    f.highestSeenRoot.Store(common.Hash(blockRoot))
    collectOnBlockLatencyToUnixTime(f.ethClock, block.Block.Slot) // fork-agnostic
}

Net effect: block_importing_latency now populates every slot the node imports a current-slot head block, on all forks.

Tests

TestCollectOnBlockLatency covers the helper's contract (records for a current-slot block, skips a past/backfill slot).

This change is a one-call relocation — the emitting helper itself is unchanged. A full cross-fork OnBlock integration test was intentionally not added, as exercising it requires substantial fork-choice/engine/PeerDAS scaffolding to make a test block "current"; flagging per the repo's TDD-pragmatism guidance. make lint and make erigon clean.

Scope

Affects release/3.4, release/3.5, and main (the call placement is identical on all three). Will cherry-pick to the release branches.

[domiwei]

Pushed a small follow-up commit to address the timing issue we discussed.

What changed:

• Capture currentSlotOnEntry early in OnBlock, after the cheap early rejects but before DA / engine work.
• Pass that captured slot into collectOnBlockLatencyToUnixTime instead of having the helper re-read GetCurrentSlot() at emit time.
• Keep the highestSeen gate, so backfill / old / duplicate blocks still do not update block_importing_latency.
• Adjust the unit test so it verifies the helper uses the supplied entry slot and does not depend on a late current-slot lookup.

Why:
A block can arrive during its own slot but cross into the next slot while DA / PeerDAS / NewPayload work runs. If the metric checks GetCurrentSlot() only at the later emit point, those higher-latency current-slot imports can be silently skipped. Capturing the slot at OnBlock entry preserves the intended head-arrival semantics while still avoiding backfill updates.

Verification run locally:

GOCACHE=/private/tmp/erigon-pr21842-gocache go test -count=1 ./cl/phase1/forkchoice
GOCACHE=/private/tmp/erigon-pr21842-gocache GOLANGCI_LINT_CACHE=/private/tmp/erigon-pr21842-golangci-cache make lint

Both passed. The first make lint attempt picked up stale golangci-lint cache entries from another deleted worktree, so I reran it with a clean GOLANGCI_LINT_CACHE; that completed with 0 issues.