fix: stop pausing paid DIPS deployments and two timing bugs

[MoonBoi9001]

TL;DR

Reviewing indexer-agent logs during a Direct Indexer Payments (DIPS) run surfaced three independent bugs: the agent pauses a subgraph it is still being paid to index, plus two timing bugs — it sizes an allocation's lifetime from a value in seconds but reads it as epochs, so the work never winds down, and it reads the current epoch from a clock that can lag the chain, so fresh work is judged stale. This fixes all three. Stacks on the duplicate-log-key PR (#1239).

Motivation

After an indexer accepts a DIPS deal, the agent indexes the subgraph it is paid for and keeps that work running for the life of the deal. Three separate things go wrong while it does that:

• Pausing a paid deployment. When the agent's in-memory list of what to index briefly drops the entry, the pause path stops a subgraph that still has an active DIPS agreement — a ~75-second gap was seen right after a deal was struck, so the indexer stops earning on work it is contracted to do.
• Timing bug 1 — allocation lifetime in the wrong unit. The agent decides how long to keep an allocation open from the agreement's collection window — the longest gap allowed between payment collections, which dipper sends in seconds. That lifetime is measured in epochs, but the seconds value was stored without converting, so a one-hour window (3,600 seconds) was read as 3,600 epochs. The allocation then effectively never expires or renews, risking lost rewards once the network treats the work as stale.
• Timing bug 2 — epoch read from a lagging clock. Each reconciliation pass reads the current epoch from a separate source that can fall behind the chain head, so the agent can judge fresh work as stale and emits logs an operator cannot reconcile against the actual chain.

The fix for each: the pause path leaves a deployment alone while it has an active DIPS agreement; the collection window is converted from seconds to epochs (using the chain's epoch length) before the indexing rule is stored; and the epoch is read once per reconciliation pass and logged with the block it was read at.