Added `client/src/block_subscription.rs`: a `BlockSubscriber` that subscribes to finalized
blocks, fetches all events per block once (every pallet), and dispatches them through a
registry of type-erased `EventPlugin`s. Each plugin pairs a parser with its own handler;
one plugin erroring or panicking is caught and logged — it never aborts the loop or starves
other plugins. The existing `EventSubscriber` / `EventParser` trait in `event_subscription.rs`
was left untouched; the new module reuses the `EventParser` seam.

Fixed a stale event type in `client/src/event_subscription.rs`: `StorageEvent::AgreementRequested`
was removed after agreement negotiation moved off-chain in commit `651726f`. The variant was dead
(parser arm could never fire) and the actual replacement events — `StorageAgreementEstablished` and
`ReplicaAgreementEstablished` — were falling through to `StorageEvent::Unknown`. The fix adds both
replacement variants with correct field shapes matching `pallet/src/lib.rs:626-641`, including a
`field_terms_scalars` helper that reads nested `AgreementTerms` scalar fields gracefully.

…r updates

Replace the plugin-based block subscriber with a Stream of raw finalized
blocks and have provider-node keep its ChainState live from it.

- pallet: ProviderSettingsUpdated / ProviderMultiaddrUpdated now carry the
  updated settings / multiaddr so off-chain consumers can apply changes
  without a re-fetch.
- storage-client: add matching StorageEvent variants + parser arms; replace
  the plugin-based BlockSubscriber (EventPlugin / ParserPlugin / isolation)
  with a Stream-based BlockSubscriberStream that yields raw finalized blocks;
  drop the now-unused plugin re-exports and example.
- provider-node: ChainStateCoordinator drives the stream in a single async
  loop — storing current_block every block and merging this provider's
  settings / multiaddr into the cached ProviderInfo in place, re-fetching the
  full info on registration.

Wire a finalized-block ChainStateCoordinator into the provider node so
it keeps current_block + provider_info in sync with the runtime, and use
current_block + request_timeout to issue bounded negotiate quotes instead
of valid_until: u32::MAX.

- ChainStateCoordinator/Handle subscribe to finalized blocks, update
  current_block on every block, and refresh provider_info on
  ProviderSettingsUpdated/ProviderMultiaddrUpdated events.
- request_timeout bootstrapped from the on-chain StorageProvider::RequestTimeout
  constant via ProviderClient::fetch_request_timeout + substrate constants module.
- negotiate_terms computes valid_until = current_block.saturating_add(request_timeout)
  and returns 503 ChainStateNotReady when either is 0.

…n chain-state readiness

- provider-node: seed a fresh NonceCounter when no on-chain replay state
  exists yet, so newly-registered (or soon-to-be) providers can negotiate
- provider-node: return ChainStateNotReady from /negotiate when the nonce
  counter is absent, and clarify the signing-unavailable error message
- papi demo: add getProviderNodeInfo and wait for the provider node to sync
  registration settings before proceeding; log block numbers; bump demo price

Reconcile the merge of origin/dev: adopt dev's reconciler-based provider_info
+ bootstrappable nonce_counter + readiness reporting, while keeping this
branch's replay-window fix (bounded valid_until = current_block +
request_timeout, ChainStateNotReady guard).

Move RequestTimeout fetching into the background reconciler (request_timeout
is now AtomicU32) so it self-heals if the chain was unreachable at boot, and
split reconcile_once into focused helpers.

The merge left provider registration info in two places: ProviderState's own
provider_info (reconciler-maintained) and chain_state.provider_info
(coordinator-maintained). Remove the former and route /negotiate, /info, and
the reconciler through chain_state.provider_info as the single source of truth.

…tate

Consolidate all on-chain state the node needs at runtime into ChainState,
with the chain-state coordinator as its only writer. Fixes the dual-writer
race between the polling reconciler and the event coordinator (review #2),
the dropped settings/multiaddr events when provider_info was None (#3), and
removes duplicated ChainState tests (#5).

- ChainState gains `constants` (PalletConstants/RequestTimeout) and
  `nonce_counter`; coordinator fetches constants once per connect, does an
  initial full sync for restart recovery, and re-fetches the full
  ProviderInfo on any relevant provider event so committed_bytes/stake/
  settings stay consistent (no field-patching).
- Drop ProviderState.request_timeout and .nonce_counter; /negotiate and
  /info now read from chain_state.
- Remove the polling reconciler (spawn_chain_reconciler + helpers) and the
  now-unused --reconcile-interval-secs CLI flag and its CI usage.
- examples/papi: replace the broken object-equality registration poll with a
  /info readiness-flag poll plus a hard timeout (review #1).

The method was never called anywhere (single definition, zero call sites).
The coordinator uses its own parse_pallet_events free function which
also filters by pallet name — the stronger, correct implementation.
Closes review finding #4.

- pallet: skip providers with deregister_at set in query_find_matching_providers
- client: surface deregister_at on ProviderInfo; add DeregisterAnnounced,
  ProviderDeregistered, and DeregisterCancelled StorageEvent variants + parsing
- provider-node: coordinator refreshes provider_info on all three deregister
  events; /negotiate returns 503 provider_deregistering when deregister_at is
  set; /info exposes a deregistering readiness flag
- tests: integration coverage for deregister lifecycle (announce, complete,
  cancel) and /info readiness flags

…indow_fixes