Introduce ResponseInstructions for OnionMessage Handling

- Currently, handle_message (or handle_custom_message) only exposes
  the generated response for an OnionMessage, lacking the necessary
  reply_path for asynchronous responses.

- This commit introduces a new flow for OnionMessage handling.

- Instead of solely taking the message as input, handle_message now accepts
  an Optional `responder`, returning a `ResponseInstruction` containing both
  the response and the reply_path.

- `ResponseInstruction` utilizes different enum variants to indicate how
  `handle_onion_message_response` should handle the response.

- This enhancement enables exposing the reply_path alongside the response
  and allows for more complex response mechanisms, such as responding with
  an added reply_path.

- The commit introduces the foundational framework (structs & enums) for this new flow.

Author: shaavan

lightning/src/onion_message/messenger.rs

@@ -243,6 +243,46 @@ impl OnionMessageRecipient {
 	}
 }
 
+
+/// The `Responder` struct creates an appropriate [`ResponseInstruction`]
+/// for a response based on our ability to respond.
+pub struct Responder {
+	/// The path along which the response can be sent.
+	reply_path: BlindedPath,
+}
+
+impl Responder {
+	/// Creates a new [`Responder`] instance with the provided reply path.
+	pub fn new(reply_path: BlindedPath) -> Self {
+		Responder {
+		    reply_path,
+		}
+	}
+
+	/// Creates the appropriate [`ResponseInstruction`] for a given response.
+	pub fn respond<T: OnionMessageContents>(self, response: T) -> ResponseInstruction<T> {
+		ResponseInstruction::WithoutReplyPath(OnionMessageResponse {
+			message: response,
+			reply_path: self.reply_path
+		})
+	}
+}
+
+/// This struct contains the information needed to reply to a received message.
+#[allow(unused)]
+pub struct OnionMessageResponse<T: OnionMessageContents> {
+	message: T,
+	reply_path: BlindedPath,
+}
+
+/// `ResponseInstruction` represents instructions for responding to received messages.
+pub enum ResponseInstruction<T: OnionMessageContents> {
+	/// Indicates that a response should be sent without including a reply path for the receiver to respond back.
+	WithoutReplyPath(OnionMessageResponse<T>),
+	/// Indicates that there's no response to send back.
+	NoResponse,
+}
+
 /// An [`OnionMessage`] for [`OnionMessenger`] to send.
 ///
 /// These are obtained when released from [`OnionMessenger`]'s handlers after which they are