Introduce recurrence handling in InvoiceRequest flow (payee side)

This commit adds payee-side handling for recurrence-enabled
`InvoiceRequest`s.

The logic now:
- Distinguishes between one-off requests, initial recurring requests, and
  successive recurring requests.
- Initializes a new `RecurrenceData` session on the first recurring
  request (counter = 0).
- Validates successive requests against stored session state
  (offset, expected counter, basetime).
- Enforces paywindow timing when applicable.
- Handles recurrence cancellation by removing the session and returning
  no invoice.

This forms the core stateful logic required for a node to act as a BOLT12
recurrence payee. Payment-acceptance and state-update logic will follow
in the next commit.

Author: shaavan

lightning/src/ln/channelmanager.rs

@@ -15403,7 +15403,7 @@ where
 					None => return None,
 				};
 
-				let invoice_request = match self.flow.verify_invoice_request(invoice_request, context) {
+				let verified_invoice_request = match self.flow.verify_invoice_request(invoice_request, context) {
 					Ok(InvreqResponseInstructions::SendInvoice(invoice_request)) => invoice_request,
 					Ok(InvreqResponseInstructions::SendStaticInvoice { recipient_id, invoice_slot, invoice_request }) => {
 						self.pending_events.lock().unwrap().push_back((Event::StaticInvoiceRequested {
@@ -15414,6 +15414,7 @@ where
 					},
 					Err(_) => return None,
 				};
+				let invoice_request = verified_invoice_request.inner();
 
 				#[cfg(not(feature = "std"))]
 				let created_at = Duration::from_secs(self.highest_seen_timestamp.load(Ordering::Acquire) as u64);
@@ -15422,6 +15423,82 @@ where
 					.duration_since(std::time::SystemTime::UNIX_EPOCH)
 					.expect("SystemTime::now() should come after SystemTime::UNIX_EPOCH");
 
+				// Recurrence checks
+				let recurrence_basetime = if let Some(recurrence_fields) = invoice_request.recurrence_fields() {
+					let payer_id = invoice_request.payer_signing_pubkey();
+					let mut sessions= self.active_recurrence_sessions.lock().unwrap();
+					
+					// We first categorise the invoice request based on it's type.
+					let recurrence_counter = invoice_request.recurrence_counter();
+					let recurrence_cancel = invoice_request.recurrence_cancel();
+					let existing_session = sessions.get(&payer_id);
+
+					match (existing_session, recurrence_counter, recurrence_cancel) {
+						// This represents case where the payer, didn't support recurrence
+						// but we set recurrence optional so we allow payer to pay one-off
+						(None, None, None) => { None },
+						// It's the first invoice request in recurrence series
+						(None, Some(0), None) => {
+							let recurrence_basetime = recurrence_fields
+								.recurrence_base
+								.map(|base| base.basetime)
+								.unwrap_or(created_at.as_secs());
+
+							// Next we prepare recurrence_data to be stored in our recurrence session
+							let recurrence_data = RecurrenceData {
+								invoice_request_start: invoice_request.recurrence_start(),
+								next_payable_counter: 0,
+								recurrence_basetime,
+							};
+							// Now we store it in our active_recurrence_session
+							sessions.insert(payer_id, recurrence_data);
+
+							Some(recurrence_basetime)
+
+						},
+						// it's a successive invoice request in recurrence series
+						(Some(data), Some(counter), None) if counter > 0 => {
+							// We confirm all the data to ensure this is an expected successive invoice request
+							if data.invoice_request_start != invoice_request.recurrence_start()
+								|| data.next_payable_counter != counter
+							{
+								return None
+							}
+
+							// Next we ensure that the successive invoice_request is received between the period's paywindow
+							if let Some(window) = recurrence_fields.recurrence_paywindow {
+								let period_index = data.invoice_request_start.unwrap_or(0) + counter;
+
+								let period_start = data.recurrence_basetime
+									+ period_index as u64 * recurrence_fields.recurrence.period_length_secs().unwrap();
+							
+								if created_at.as_secs() < period_start - window.seconds_before as u64
+									|| created_at.as_secs() >= period_start + window.seconds_after as u64
+								{
+									return None
+								}
+							}
+
+							Some(data.recurrence_basetime)
+						},
+						// it's a cancel recurrence invoice request
+						(Some(_data), Some(counter), Some(())) if counter > 0 => {
+							// Here we simply remove the data from our sessions
+							sessions.remove(&payer_id);
+
+							// And since cancellation invoice request are stub invoice request,
+							// we don't respond to this invoice request
+							return None
+						},
+						_ => {
+							debug_assert!(false, "Should be unreachable, as all the invalid cases are handled during parsing");
+							return None
+						}
+					}
+				} else {
+					None
+				};
+
 				let get_payment_info = |amount_msats, relative_expiry| {
 					self.create_inbound_payment(
 						Some(amount_msats),
@@ -15430,7 +15507,7 @@ where
 					).map_err(|_| Bolt12SemanticError::InvalidAmount)
 				};
 
-				let (result, context) = match invoice_request {
+				let (result, context) = match verified_invoice_request {
 					InvoiceRequestVerifiedFromOffer::DerivedKeys(request) => {
 						let result = self.flow.create_invoice_builder_from_invoice_request_with_keys(
 							&self.router,
@@ -15441,7 +15518,11 @@ where
 						);
 
 						match result {
-							Ok((builder, context)) => {
+							Ok((mut builder, context)) => {
+								recurrence_basetime.map(|basetime| 
+									builder.set_invoice_recurrence_basetime(basetime)
+								);
+
 								let res = builder
 									.build_and_sign(&self.secp_ctx)
 									.map_err(InvoiceError::from);
@@ -15466,7 +15547,10 @@ where
 						);
 
 						match result {
-							Ok((builder, context)) => {
+							Ok((mut builder, context)) => {
+								recurrence_basetime.map(|basetime| 
+									builder.set_invoice_recurrence_basetime(basetime)
+								);
 								let res = builder
 									.build()
 									.map_err(InvoiceError::from)