chore: deflake duplicate attestations and proposals slash tests

[mrzeszutko]

Summary

Fixes a race condition in the duplicate_attestation_slash and duplicate_proposal_slash e2e tests that caused intermittent timeouts waiting for slashing offenses to be detected.

Root Cause

Investigated CI failure 2abee794200ae6a7 (commit f71c235a670d, merge queue for PR #20555). This run did include the fix from #20990, yet the duplicate_attestation_slash test still failed with a timeout after ~478 seconds.

The failure sequence from the logs:

1. awaitEpochWithProposer found the malicious proposer at slot 14 (epoch 7)
2. The function returned, having warped L1 time to the start of epoch 7
3. Sequencers were then started (await Promise.all(nodes.map(n => n.getSequencer()!.start())))
4. By the time sequencers were ready to build blocks, L1 time had advanced past epoch 7 into epoch 8 (first block built at slot 16)
5. The malicious proposer was never selected in epoch 8+, so no duplicate proposals/attestations were created
6. The slasher had nothing to detect, and the test timed out

The core issue: awaitEpochWithProposer warped to the target epoch and returned, but starting sequencers takes real time. With only 2 slots per epoch (48s total), the epoch passed before sequencers could act.

Fix

Renamed awaitEpochWithProposer to advanceToEpochBeforeProposer and changed the approach to a two-phase pattern:

1. Find phase: The function now checks the next epoch's slots (N+1) instead of the current epoch's (N). When the target proposer is found, it returns { targetEpoch } while staying at epoch N -- one full epoch before the target.

2. Start + warp phase (in the test): After the function returns, sequencers are started while still one epoch before the target. Only then does the test warp to the target epoch via advanceToEpoch(targetEpoch).

This eliminates the race because sequencers are already running when the target epoch begins.

The function can safely query future epoch slots because epochCache.getProposerAttesterAddressInSlot works for any slot within the lagInEpochsForValidatorSet window (typically 2 epochs ahead), and we only look 1 epoch ahead.

Changes

• shared.ts: Renamed awaitEpochWithProposer -> advanceToEpochBeforeProposer. Now checks next epoch's slots and returns { targetEpoch: EpochNumber } instead of void.
• duplicate_attestation_slash.test.ts: Updated to start sequencers before warping to target epoch.
• duplicate_proposal_slash.test.ts: Same change. Also filtered offense assertions to only check DUPLICATE_PROPOSAL offenses, since the two malicious nodes sharing the same key each self-attest to their own (different) checkpoint proposals, causing honest nodes to also detect a DUPLICATE_ATTESTATION offense.

Fixes A-632