MDK-980: Claim wire + verification in the LSP

[amackillop]

Summary

Lets a registering node carry a signed grant for a non-standard FeePolicy.
The LSP verifies the grant locally (no network I/O), persists the granted
policy onto the peer's SCID record before the SCID is handed out, and honors
it at the skim site. Inert in production: with no issuer key configured every
peer resolves Flat(Standard) and is skimmed the same 2% as today.

Builds on MDK-979 (#24), which
landed the FeePolicy/FeeTier ADT, resolve_skim, and the policy TLV on
ScidWithPeer. That work deferred the per-peer lookup; this PR makes the grant
real and wires that lookup up.

Companion PR: the issuer side (MDK-982,
the open-money TS minter) is CumuloGlobal/open-money#468. It mints the fee_claim
this PR verifies and pins the same in-tree test vector, so the two are validated
against each other.

What changed

Five atomic commits, just check green after each.

• Claim ADT + verifier (claim.rs, new). ClaimPayload { scheme, node_id, policy } and SignedFeeClaim { payload, sig }, both TLV. The signature is
  BIP340 over SHA256(ClaimPayload.encode()); the outer container keeps the
  payload as opaque bytes so the verifier hashes exactly what was signed and
  never re-derives the TLV layout. verify_claim takes a slice of issuer keys
  (empty rejects everything), checks the scheme, the signature against any one
  key, and the node_id binding.
• fee_claim on RegisterNodeRequest (msgs.rs, client.rs). Optional
  hex string, skip_serializing_if = "Option::is_none". An old client sending
  {} still decodes to None, and a node with no claim emits {}, so the wire
  is unchanged when no claim is set.
• Policy retention in the SCID store (scid_store.rs). A policy_by_peer
  map kept in lockstep with the existing peer<->scid maps: built on load,
  upserted on insert, dropped on remove. get_policy reads it back.
• Issuer keys + verify/persist in the handler (service.rs).
  issuer_pubkeys: Vec<XOnlyPublicKey> on LSPS4ServiceConfig, a long-lived
  verify context on the handler, and register_node resolving any presented
  claim into the SCID record before the response is enqueued.
• Honor the policy at the skim site (service.rs).
  calculate_htlc_actions_for_peer reads the peer's policy from the store
  instead of the literal Flat(Standard).

Decisions

• Never downgrade, but only against absence. A valid claim is authoritative
  and upserts the policy in either direction. An absent or unverifiable claim
  returns None and leaves a live record untouched, so a transient miss or a
  malformed claim on a later re-registration can't silently restore the 2% skim
  on a node that was granted zero-fee. This deviates from a literal "else
  Standard" on purpose.
• Issuer keys are a Vec, not a single Option. Empty disables the feature.
  A non-empty set accepts a signature from any one key, which covers a no-key-id
  claim today and key rotation later without a breaking config change. Per-key
  policy scope (a promo key that must not grant permanent zero-fee) is a known
  gap: it slots in additively as a keyed &[(key, scope)] plus a payload key-id.
• The wire format is the cross-repo contract. claim.rs ships an in-tree
  test vector (fixed issuer secret, fixed node secret, a ZeroFee claim pinned
  to its hex and issuer x-only key). The TS minter (open-money#468) already
  reproduces it byte-for-byte, and
  MDK-981 (ldk-node) will too;
  drift fails the test instead of diverging silently.
• TLV, not fixed concatenation. New policy arms or an issuer key-id are new
  tags, additive, no re-issue.
• The verifier borrows the caller's secp context rather than allocating per
  call; the service owns one long-lived verify context.

Behaviour preservation

Empty issuer_pubkeys short-circuits before any crypto, so every peer resolves
Flat(Standard) and the skim is byte-for-byte the historical 2%. The on-disk
ScidWithPeer layout is unchanged (the policy TLV default predates this work),
so no migration. A node only populates fee_claim once
MDK-981 and
MDK-982 land, so even with the
code merged nothing presents a claim until then.

Tests

• claim.rs: payload round-trip, valid claim yields the granted policy, empty
  issuer set rejects, wrong key rejects, forged signature rejects, node_id
  mismatch, unknown scheme, malformed hex/TLV, multi-issuer second key verifies,
  a Custom policy survives verify, and the in-tree test vector.
• msgs.rs: round-trip with a claim, field omitted when None, legacy {}
  decodes to None.
• scid_store.rs: insert-with-policy then get_policy, load rebuilds the map,
  default record resolves to Standard, plus the existing serialization tests.

The handler glue (resolve + persist) and the skim read are not unit-tested: the
pure pieces they compose are, and exercising the handler needs the full node
harness which is saved for future integration test work.

Follow-ups

• MDK-981 (ldk-node): plumb
  a fee_claim value into register_node (client role) and surface
  issuer_pubkeys config (LSP role).
• Per-key issuer scope: deferred until a second, less-trusted issuer exists.
• lsps4_integration_tests.rs is untracked and fully commented out; whoever
  revives that harness adds issuer_pubkeys: Vec::new() to its config literal.