Fix bitcoind shutdown hang during initial sync errors and polling

When using bitcoind chain source, `Node::stop()` could hang indefinitely
if called during:
1. Initial sync error backoff (up to 5 minutes of sleep)
2. Active polling operations in the continuous sync loop

This is a more severe variant of the background sync hang issue, as the
bitcoind initial sync loop had NO stop signal checking at all.

## Root Cause

### Initial Sync Loop

The `BitcoindChainSource::continuously_sync_wallets()` initial sync loop
(lines 149-277) performs synchronization on startup. When sync fails
(e.g., "Connection refused" when bitcoind is unavailable), it enters an
exponential backoff retry loop:

- Transient errors: Sleep for `backoff` seconds (10s, 20s, 40s, 80s,
  160s, up to 300s)
- Persistent errors: Sleep for MAX_BACKOFF_SECS (300 seconds)

These sleeps had NO stop signal checking. When shutdown was requested:
1. Initial sync fails with connection error
2. Code sleeps for backoff period (up to 5 minutes)
3. User calls `stop()`
4. Stop signal sent but ignored - stuck sleeping
5. Shutdown times out after 5 seconds and aborts
6. Initial sync loop never exits cleanly

### Continuous Polling Loop

The continuous polling loop (lines 296-349) had the same issue as
electrum/esplora - no biased select and no cancellation of in-progress
operations.

## Solution

### Initial Sync Loop Fix

1. Added biased `tokio::select!` at loop start to check stop signal
   before beginning each sync attempt
2. Wrapped both error backoff sleeps in biased `tokio::select!` to
   allow immediate interruption when stop is requested

This ensures that even if bitcoind is down and the node is retrying
with exponential backoff, shutdown completes immediately instead of
waiting up to 5 minutes.

### Continuous Polling Loop Fix

Applied the same biased nested `tokio::select!` pattern used for
electrum/esplora:
- Outer biased select prioritizes stop signal before polling intervals
- Inner nested selects allow cancellation of in-progress operations

## Testing

Existing unit tests pass. The shutdown will now complete in milliseconds
instead of hanging for minutes when bitcoind is unreachable.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: benthecarman

src/chain/bitcoind.rs

@@ -147,6 +147,19 @@ impl BitcoindChainSource {
 		const MAX_BACKOFF_SECS: u64 = 300;
 
 		loop {
+			// Check for stop signal at the beginning of each iteration
+			tokio::select! {
+				biased;
+				_ = stop_sync_receiver.changed() => {
+					log_trace!(
+						self.logger,
+						"Stopping initial chain sync.",
+					);
+					return;
+				}
+				_ = async {} => {}
+			}
+
 			let channel_manager_best_block_hash = channel_manager.current_best_block().block_hash;
 			let sweeper_best_block_hash = output_sweeper.current_best_block().block_hash;
 			let onchain_wallet_best_block_hash =
@@ -226,7 +239,18 @@ impl BitcoindChainSource {
 									e,
 									backoff
 								);
-						tokio::time::sleep(Duration::from_secs(backoff)).await;
+						// Sleep with stop signal check to allow immediate shutdown
+						tokio::select! {
+							biased;
+							_ = stop_sync_receiver.changed() => {
+								log_trace!(
+									self.logger,
+									"Stopping initial chain sync during backoff.",
+								);
+								return;
+							}
+							_ = tokio::time::sleep(Duration::from_secs(backoff)) => {}
+						}
 						backoff = std::cmp::min(backoff * 2, MAX_BACKOFF_SECS);
 					} else {
 						log_error!(
@@ -235,7 +259,18 @@ impl BitcoindChainSource {
 									e,
 									MAX_BACKOFF_SECS
 								);
-						tokio::time::sleep(Duration::from_secs(MAX_BACKOFF_SECS)).await;
+						// Sleep with stop signal check to allow immediate shutdown
+						tokio::select! {
+							biased;
+							_ = stop_sync_receiver.changed() => {
+								log_trace!(
+									self.logger,
+									"Stopping initial chain sync during backoff.",
+								);
+								return;
+							}
+							_ = tokio::time::sleep(Duration::from_secs(MAX_BACKOFF_SECS)) => {}
+						}
 					}
 				},
 			}
@@ -260,6 +295,8 @@ impl BitcoindChainSource {
 		let mut last_best_block_hash = None;
 		loop {
 			tokio::select! {
+				biased;
+
 				_ = stop_sync_receiver.changed() => {
 					log_trace!(
 						self.logger,
@@ -268,17 +305,43 @@ impl BitcoindChainSource {
 					return;
 				}
 				_ = chain_polling_interval.tick() => {
-					let _ = self.poll_and_update_listeners(
-						Arc::clone(&channel_manager),
-						Arc::clone(&chain_monitor),
-						Arc::clone(&output_sweeper)
-					).await;
+					tokio::select! {
+						biased;
+						_ = stop_sync_receiver.changed() => {
+							log_trace!(
+								self.logger,
+								"Stopping polling for new chain data.",
+							);
+							return;
+						}
+						res = self.poll_and_update_listeners(
+							Arc::clone(&channel_manager),
+							Arc::clone(&chain_monitor),
+							Arc::clone(&output_sweeper)
+						) => {
+							let _ = res;
+						}
+					}
 				}
 				_ = fee_rate_update_interval.tick() => {
-					if last_best_block_hash != Some(channel_manager.current_best_block().block_hash) {
-						let update_res = self.update_fee_rate_estimates().await;
-						if update_res.is_ok() {
-							last_best_block_hash = Some(channel_manager.current_best_block().block_hash);
+					tokio::select! {
+						biased;
+						_ = stop_sync_receiver.changed() => {
+							log_trace!(
+								self.logger,
+								"Stopping polling for new chain data.",
+							);
+							return;
+						}
+						res = async {
+							if last_best_block_hash != Some(channel_manager.current_best_block().block_hash) {
+								let update_res = self.update_fee_rate_estimates().await;
+								if update_res.is_ok() {
+									last_best_block_hash = Some(channel_manager.current_best_block().block_hash);
+								}
+							}
+						} => {
+							let _ = res;
 						}
 					}
 				}