fix: drive the fee provider from the archiver's L1 sync point

[spalladino]

Fixes A-1904. Part of A-1903.
Design: https://claude.ai/code/artifact/e9b78bd2-501d-4c30-a81a-5a10cbeed392

Stacked on #25384. Third of five PRs on the fee-quote / public-simulation series.

Problem

The node ran two independent L1 pollers. FeeProviderImpl polled getBlockNumber() on its own schedule and
the archiver polled L1 on its own, so for up to one poll interval the two held different views of the chain.
Both answer the same underlying question — the minimum mana fee for a block in slot X — and the answer is a
step function of the slot, so a disagreement about which checkpoints exist shows up as a wallet quote the
node's own public simulation then rejects.

Worked example. L1 mines checkpoint 14 at slot 41. The archiver's next pass runs 200ms later and its frontier
now reports checkpoint 14 as the checkpointed tip, so the simulator prices the next block at slot 42. The fee
provider's own poll has not fired yet, so its cached "current min fees" still describes the L1 block before
checkpoint 14 landed and prices slot 41. If the L1 gas oracle stepped at slot 42, the wallet quotes the slot-41
fee, pads it, and the simulation charges the slot-42 fee and rejects the transaction. The same window exists in
reverse when the fee provider polls first.

On top of that, the provider read the "current" fee at latest even though it pinned the predictor's reads to
a block number, so a single quote could mix two L1 blocks.

Design

• Sync point source. L2BlockSource gains getL1SyncPoint(), returning the same { blockNumber, blockHash } that getL2Frontier().l1SyncPoint carries (added in fix: read archiver tips and proposed checkpoint as one atomic snapshot #25384). The archiver serves it from the
  frontier cache without awaiting the snapshot promise, so following it costs a field read, not a store or L1
  call. The fee provider depends on that one method only (Pick<L2BlockSource, 'getL1SyncPoint'>).
• Refresh on hash change. FeeProviderImpl no longer polls an L1 head of its own. Its loop reads the sync
  point and refreshes only when the hash differs from the newest entry's — hash, not number, so a same-height
  L1 reorg still invalidates. Before the archiver's first pass the sync point is undefined and the provider
  falls back to L1's latest block, so a starting node can answer fee queries while the archiver catches up.
• Every read pinned. getPendingCheckpoint and getTimestampForSlot gained an optional { blockNumber },
  and getManaMinFeeAt takes { stateOverride?, blockNumber? } as a single options bag (threaded through
  getCheckpointNumber / getCheckpoint, guarded by checkBlockTag like the other pinned readers); the
  predictor's state read was already pinned. One refresh therefore describes exactly one L1 block.
• Ring of 4. Each refresh appends { blockNumber, blockHash, currentMinFees, predictorState },
  newest first. FeePredictor no longer caches state internally: computeState(blockNumber) returns it and
  computePredictions(state, manaUsage) derives fees from it, so each retained view carries its own state and
  a tagged answer is computed from the state read at that block.
• Single-flight. One in-flight refresh promise, shared by the loop and every waiting request. A burst of
  requests during a transition costs one round of L1 reads.
• asOf tagging. getCurrentMinFees(asOf?) and getPredictedMinFees(manaUsage?, asOf?) take an optional
  { blockNumber, maxWaitMs? }. Untagged serves the newest view. A tag the ring holds is served from that
  view even when a newer one exists. A tag ahead of every view awaits the shared refresh and, if the pass it
  joined had already started from an older sync point and so did not produce its block, one more pass of its
  own — both within maxWaitMs when set, falling through to the newest view on timeout — and then serves the
  match, or the newest view with a debug log. A tag behind the ring serves the oldest view with a debug log. A tagged miss
  never throws; only the initial start() refresh propagates errors. getPredictedMinFees still returns
  [currentMinFees, ...predictions], both halves from the same entry.
• Who tags. In this PR the only tagged caller is the public simulator, which passes its frontier's sync
  point when pricing a checkpoint boundary (buildCheckpointGlobalVariables gained a trailing
  { blockNumber }). PR 4 adds the next-block predictor and PR 5 the fee quote. Admission — isValidTx,
  gossip validation, pool ingress and eviction — stays untagged and unchanged: it tolerates staleness and must
  not gain a wait.

Residuals

• The overrides plan built for the simulation (buildSimulationOverridesStateOverride and the pipelined parent
  fee-header reads inside buildCheckpointSimulationOverridesPlan) is still read unpinned. Those reads describe
  the proposed parent, which the frontier snapshot already pins logically, but they are not yet pinned to an L1
  block number.
• Fee freshness is now bounded by the archiver's poll interval plus the provider's, rather than the provider's
  alone. That is the point of the change — both sides move together — but it does mean an L1-driven oracle step
  reaches the quote slightly later than before.

Tests

• fee_provider.test.ts rewritten against a stub sync-point source and mocked contract/predictor: pinned reads
  (the block number passed to each contract call is asserted — here the pin is the behaviour), refresh only on
  hash change with no head poll, same-height reorg refreshes, L1-head fallback before the first archiver pass,
  tagged hit served past a newer view, tagged miss refreshing and serving, single-flight across two concurrent
  misses, capped wait serving the newest view, tag behind the ring serving the oldest, ring capped at four,
  start failing on a failed initial refresh, and a failed background refresh leaving the last view intact.
• node_public_calls_simulator.test.ts: the boundary fee read is pinned to the frontier's sync point, and left
  unpinned when the archiver has not synced.
• fee_quote_vs_simulation.integration.test.ts (anvil): the mocked archiver now reports a real sync point and
  the provider is built against it. Both existing cases stay green, and a new case lands a checkpoint on L1,
  mines past it, and shows the quote unchanged while the archiver has not run a pass, then moving to the new
  fee together with the simulation once the sync point advances. This is what proves pinned eth_call with a
  stateOverride works against anvil at a recent block.
• fee_predictor.test.ts updated to the new computeState / computePredictions API; the state-caching block
  is gone with the cache.
• archiver-sync.test.ts asserts getL1SyncPoint() matches the frontier's field after a sync pass;
  stdlib/src/interfaces/archiver.test.ts round-trips the new RPC method.

Next PR moves next-block planning and the boundary fee cache out of the simulator.