Refactor initiate_async_payment to improve separation of concerns

1. Previously, `initiate_async_payment` handled both the outbound payment
state update (marking a static invoice as received) and the message
queuing for async payments. This tightly coupled two distinct
responsibilities within `ChannelManager`.

2. This refactor **separates concerns** by moving message queuing into
a separate function, allowing `initiate_async_payment` to focus solely
on updating `pending_outbound_payments`. This paves the way for moving
message queuing to `flow.rs` in upcoming commits, ensuring
`MessageRouter` logic remains independent of `ChannelManager`.

3. **This introduces a behavior change:** Since `pending_outbound_payments`
is now handled separately, we drop PersistenceNotifierGuard before queuing
messages. As a result, `NotifyOption` is no longer called for the message
queuing process.

4. **Why is this safe?** Because `pending_async_payments_messages` is
**not under `total_consistency_lock`**, meaning it does not require
persistence notifications. This aligns with the lock order tree and
maintains correct locking discipline.

By making this change, we improve modularity, enforce a cleaner separation
between `ChannelManager` and `MessageRouter`, and remove unnecessary
persistence dependencies.

Author: shaavan

lightning/src/ln/channelmanager.rs

@@ -4480,7 +4480,7 @@ where
 	}
 
 	#[cfg(async_payments)]
-	fn initiate_async_payment(
+	fn handle_static_invoice_received(
 		&self, invoice: &StaticInvoice, payment_id: PaymentId
 	) -> Result<(), Bolt12PaymentError> {
 		let mut res = Ok(());
@@ -4502,43 +4502,51 @@ where
 					return NotifyOption::DoPersist
 				}
 			};
-
-			let nonce = Nonce::from_entropy_source(&*self.entropy_source);
-			let hmac = payment_id.hmac_for_async_payment(nonce, &self.inbound_payment_key);
-			let reply_paths = match self.create_blinded_paths(
-				MessageContext::AsyncPayments(
-					AsyncPaymentsContext::OutboundPayment { payment_id, nonce, hmac }
-				)
-			) {
-				Ok(paths) => paths,
-				Err(()) => {
-					self.abandon_payment_with_reason(payment_id, PaymentFailureReason::BlindedPathCreationFailed);
-					res = Err(Bolt12PaymentError::BlindedPathCreationFailed);
-					return NotifyOption::DoPersist
-				}
-			};
-
-			let mut pending_async_payments_messages = self.pending_async_payments_messages.lock().unwrap();
-			const HTLC_AVAILABLE_LIMIT: usize = 10;
-			reply_paths
-				.iter()
-				.flat_map(|reply_path| invoice.message_paths().iter().map(move |invoice_path| (invoice_path, reply_path)))
-				.take(HTLC_AVAILABLE_LIMIT)
-				.for_each(|(invoice_path, reply_path)| {
-					let instructions = MessageSendInstructions::WithSpecifiedReplyPath {
-						destination: Destination::BlindedPath(invoice_path.clone()),
-						reply_path: reply_path.clone(),
-					};
-					let message = AsyncPaymentsMessage::HeldHtlcAvailable(HeldHtlcAvailable {});
-					pending_async_payments_messages.push((message, instructions));
-				});
-
 			NotifyOption::DoPersist
 		});
 
 		res
 	}
 
+	#[cfg(async_payments)]
+	fn initiate_async_payment(
+		&self, invoice: &StaticInvoice, payment_id: PaymentId
+	) -> Result<(), Bolt12PaymentError> {
+
+		self.handle_static_invoice_received(invoice, payment_id)?;
+
+		let nonce = Nonce::from_entropy_source(&*self.entropy_source);
+		let hmac = payment_id.hmac_for_async_payment(nonce, &self.inbound_payment_key);
+		let reply_paths = match self.create_blinded_paths(
+			MessageContext::AsyncPayments(
+				AsyncPaymentsContext::OutboundPayment { payment_id, nonce, hmac }
+			)
+		) {
+			Ok(paths) => paths,
+			Err(()) => {
+				self.abandon_payment_with_reason(payment_id, PaymentFailureReason::BlindedPathCreationFailed);
+				return Err(Bolt12PaymentError::BlindedPathCreationFailed);
+			}
+		};
+
+		let mut pending_async_payments_messages = self.pending_async_payments_messages.lock().unwrap();
+		const HTLC_AVAILABLE_LIMIT: usize = 10;
+		reply_paths
+			.iter()
+			.flat_map(|reply_path| invoice.message_paths().iter().map(move |invoice_path| (invoice_path, reply_path)))
+			.take(HTLC_AVAILABLE_LIMIT)
+			.for_each(|(invoice_path, reply_path)| {
+				let instructions = MessageSendInstructions::WithSpecifiedReplyPath {
+					destination: Destination::BlindedPath(invoice_path.clone()),
+					reply_path: reply_path.clone(),
+				};
+				let message = AsyncPaymentsMessage::HeldHtlcAvailable(HeldHtlcAvailable {});
+				pending_async_payments_messages.push((message, instructions));
+			});
+
+		Ok(())
+	}
+
 	#[cfg(async_payments)]
 	fn send_payment_for_static_invoice(
 		&self, payment_id: PaymentId