Add initializer with LambdaHandler directly with Decodable event and Void output (#589)

_Add convenience initializer for `LambdaRuntime` to accept
`LambdaHandler` instances with `Void` output_

### Motivation:

Following PR #581, which added convenience initializers for
`LambdaRuntime` to accept `LambdaHandler` instances with `Encodable`
outputs, there was still a gap for handlers that return `Void`. This is
useful, for example, for AWS event sources like SQS, where the
`AWSLambdaEvents` package provides `SQSEvent` but there's no
corresponding output type - handlers simply process messages and return
`Void`.

Without this initializer, developers had to manually wrap their handlers
with `LambdaCodableAdapter` and `LambdaHandlerAdapter`, which was
verbose and inconsistent with the new API (similar to what is described
in #581)

### Modifications:

1. Added a new `init(decoder:handler:)` convenience initializer to
`LambdaCodableAdapter` in `Lambda+JSON.swift` that accepts a
`JSONDecoder` for handlers with `Void` output.

2. Added a new convenience initializer to `LambdaRuntime` that accepts a
`LambdaHandler` instance with `Void` output directly, handling the
wrapping internally.

3. Updated documentation comments to distinguish between handlers with
`Void` and `Encodable` outputs.

### Result:

Developers can now initialize `LambdaRuntime` with handlers that return
`Void` using a clean, direct API. This is especially useful for event
sources like SQS:

```swift
import AWSLambdaEvents

struct MySQSHandler: LambdaHandler {
    func handle(_ event: SQSEvent, context: LambdaContext) async throws {
        // Process SQS messages
    }
}

let runtime = LambdaRuntime(lambdaHandler: MySQSHandler())
```

This provides API completeness, matching the convenience initializers
for handlers with `Encodable` outputs, and delivers better ergonomics
for common serverless patterns.

Author: natanrolnik

Sources/AWSLambdaRuntime/FoundationSupport/Lambda+JSON.swift

@@ -83,7 +83,28 @@ extension LambdaCodableAdapter {
             handler: handler
         )
     }
+
+    /// Initializes an instance given a decoder, and a handler with a `Void` output.
+    ///   - Parameters:
+    ///   - decoder: The decoder object that will be used to decode the received `ByteBuffer` event into the generic `Event` type served to the `handler`. By default, a JSONDecoder is used.
+    ///   - handler: The handler object.
+    public init(
+        decoder: JSONDecoder = JSONDecoder(),
+        handler: sending Handler
+    )
+    where
+        Output == Void,
+        Handler.Output == Void,
+        Decoder == LambdaJSONEventDecoder,
+        Encoder == VoidEncoder
+    {
+        self.init(
+            decoder: LambdaJSONEventDecoder(decoder),
+            handler: handler
+        )
+    }
 }
+
 @available(LambdaSwift 2.0, *)
 extension LambdaResponseStreamWriter {
     /// Writes the HTTP status code and headers to the response stream.
@@ -161,12 +182,41 @@ extension LambdaRuntime {
         self.init(handler: handler, logger: logger)
     }
 
-    /// Initialize an instance directly with a `LambdaHandler`.
+    /// Initialize an instance directly with a `LambdaHandler`, when `Event` is `Decodable` and `Output` is `Void`.
+    /// - Parameters:
+    ///   - decoder: The decoder object that will be used to decode the incoming `ByteBuffer` event into the generic `Event` type. `JSONDecoder()` used as default.
+    ///   - logger: The logger to use for the runtime. Defaults to a logger with label "LambdaRuntime".
+    ///   - lambdaHandler: A type that conforms to the `LambdaHandler` protocol, whose `Event` is `Decodable` and `Output` is `Void`
+    public convenience init<Event: Decodable, LHandler: LambdaHandler>(
+        decoder: JSONDecoder = JSONDecoder(),
+        logger: Logger = Logger(label: "LambdaRuntime"),
+        lambdaHandler: sending LHandler
+    )
+    where
+        Handler == LambdaCodableAdapter<
+            LambdaHandlerAdapter<Event, Void, LHandler>,
+            Event,
+            Void,
+            LambdaJSONEventDecoder,
+            VoidEncoder
+        >,
+        LHandler.Event == Event,
+        LHandler.Output == Void
+    {
+        let handler = LambdaCodableAdapter(
+            decoder: LambdaJSONEventDecoder(decoder),
+            handler: LambdaHandlerAdapter(handler: lambdaHandler)
+        )
+
+        self.init(handler: handler, logger: logger)
+    }
+
+    /// Initialize an instance directly with a `LambdaHandler`, when `Event` is `Decodable` and `Output` is `Encodable`.
     /// - Parameters:
     ///   - decoder: The decoder object that will be used to decode the incoming `ByteBuffer` event into the generic `Event` type. `JSONDecoder()` used as default.
     ///   - encoder: The encoder object that will be used to encode the generic `Output` into a `ByteBuffer`. `JSONEncoder()` used as default.
     ///   - logger: The logger to use for the runtime. Defaults to a logger with label "LambdaRuntime".
-    ///   - lambdaHandler: A type that conforms to the `LambdaHandler` protocol, whose `Event` and `Output` types must be `Decodable`/`Encodable`
+    ///   - lambdaHandler: A type that conforms to the `LambdaHandler` protocol, whose `Event` is `Decodable` and `Output` is `Encodable`
     public convenience init<Event: Decodable, Output, LHandler: LambdaHandler>(
         decoder: JSONDecoder = JSONDecoder(),
         encoder: JSONEncoder = JSONEncoder(),