Prevent spurious splice on reconnect

When the LSP intercepts an HTLC for an offline peer, the peer
reconnects and peer_connected fires before channel_reestablish
completes. All channels report is_usable=false at this point.

calculate_htlc_actions_for_peer builds its capacity map from
is_usable channels (empty set), finds zero capacity, then falls
through to the splice candidate filter. That filter used
is_channel_ready, which matches mid-reestablish channels, so it
emits a splice. Once reestablish finishes,
the HTLC gets forwarded through the existing
channel. The splice was wasted, and the 30s liquidity cooldown
it sets blocks all subsequent liquidity actions for that peer.

Two fixes in calculate_htlc_actions_for_peer:

1. Early return when channels exist but none are usable. The
   capacity map is empty so any decision would be wrong. The
   HTLC stays in the store (persisted by the prior commit) and
   the 1Hz timer retries once channels become usable.

2. Splice candidate filter changed from is_channel_ready to
   is_usable. A mid-reestablish channel maye already have sufficient
   capacity but it's just not visible yet. Splicing into it adds
   unnecessary on-chain cost and a 30s cooldown for capacity
   that was never actually insufficient. splice_channel() would
   also fail if the channel does become usable in time.

Author: amackillop

lightning-liquidity/src/lsps4/service.rs

@@ -706,6 +706,25 @@ where
 			htlcs.len()
 		);
 
+		// Channels exist but none are usable (reestablish in progress).
+		// Return empty actions. We can't forward and we must not decide to splice or
+		// open a new channel based on stale capacity. The timer retries once usable.
+		if !channels.is_empty() && channel_capacity_map.is_empty() {
+			log_info!(
+				self.logger,
+				"[LSPS4] calculate_htlc_actions: {} has {} channels but none usable yet \
+				 - deferring decision",
+				their_node_id,
+				channels.len()
+			);
+			return HtlcProcessingActions {
+				forwards: vec![],
+				new_channel_needed_msat: None,
+				splice_needed: None,
+				channel_count,
+			};
+		}
+
 		struct ComputedHtlc {
 			htlc: InterceptedHtlc,
 			amount_to_forward_msat: u64,
@@ -783,12 +802,13 @@ where
 					.fold(required_amount, |acc, h| acc.saturating_add(h.amount_to_forward_msat));
 
 				// Prefer splicing into the largest usable channel over opening a new one.
-				// Use is_channel_ready (not is_usable) so we prefer splice even during
-			// channel_reestablish. splice_channel() will fail if the channel isn't
-			// usable yet, and the timer will retry once reestablishment completes.
-			let splice_candidate = channels
+				// Only splice into usable channels. A mid-reestablish channel may
+				// already have sufficient capacity that just isn't visible yet;
+				// splice_channel() would also reject if the channel does become
+				// usable in time.
+				let splice_candidate = channels
 					.iter()
-					.filter(|c| c.is_channel_ready)
+					.filter(|c| c.is_usable)
 					.max_by_key(|c| c.channel_value_satoshis);
 
 				if let Some(candidate) = splice_candidate {