Lambda Handler errors now reports the root error in field errorType rather than "FunctionError" constant (#587)

### Motivation:

Fix for Issue
[#580](#580),
by making it so that the `errorType` in failed requests will be the type
of the error entity, rather than a hardcoded string of `FunctionError`.
This allows orchestration within step functions that perform retry/catch
logic based on different error output types.

### Modifications:

At a high level, the issue is that swift-aws-lambda-runtime, when an
error is thrown, outputs the errorType as hardcoded to FunctionError.
You can see that
[here](https://github.com/swift-server/swift-aws-lambda-runtime/blob/main/Sources/AWSLambdaRuntime/LambdaRuntimeClient%2BChannelHandler.swift#L337):

```
let errorResponse = ErrorResponse(errorType: Consts.functionError, errorMessage: "\(error)")
```

This PR changes this for all cases to output the type of the error,
rather than the hardcoded string:
```
let errorResponse = ErrorResponse(errorType: "\(type(of: error))", errorMessage: "\(error)")
```
Now, I will show 2 examples with this solution:
```
let runtime = LambdaRuntime {
    (event: Input, context: LambdaContext) in

    enum MyTestErrorType: Error {
        case testError
    }
    
    throw MyTestErrorType.testError
}

// outputs {"errorType":"MyTestErrorType","errorMessage":"testError"}
```
```
let dynamoDB: DynamoDB = DynamoDB(client: .init())

let runtime = LambdaRuntime {
    (event: Input, context: LambdaContext) in

    let _ = try await dynamoDB.putItem(DynamoDB.PutItemInput(item: [:], tableName: ""))
    
    return Output()
}

// outputs {"errorType":"AWSClientError","errorMessage":"ValidationError: Length of PutItemInput.tableName (0) is less than minimum allowed value 1."}
```

Author: benrosen78

Sources/AWSLambdaRuntime/LambdaRuntimeClient+ChannelHandler.swift

@@ -334,7 +334,7 @@ internal final class LambdaChannelHandler<Delegate: LambdaChannelHandlerDelegate
             self.reusableErrorBuffer!.clear()
         }
 
-        let errorResponse = ErrorResponse(errorType: Consts.functionError, errorMessage: "\(error)")
+        let errorResponse = ErrorResponse(errorType: "\(type(of: error))", errorMessage: "\(error)")
         // TODO: Write this directly into our ByteBuffer
         let bytes = errorResponse.toJSONBytes()
         self.reusableErrorBuffer!.writeBytes(bytes)

Sources/AWSLambdaRuntime/Utils.swift

@@ -24,7 +24,6 @@ enum Consts {
     static let postResponseURLSuffix = "/response"
     static let postErrorURLSuffix = "/error"
     static let postInitErrorURL = "\(apiPrefix)/runtime/init/error"
-    static let functionError = "FunctionError"
     static let initializationError = "InitializationError"
 }
 

Tests/AWSLambdaRuntimeTests/LambdaRuntimeClientTests.swift

@@ -330,4 +330,78 @@ struct LambdaRuntimeClientTests {
             }
         }
     }
+
+    @Test(
+        "reportError() sends the correct errorType for different Error types"
+    )
+    @available(LambdaSwift 2.0, *)
+    func testReportErrorReturnsProperErrorType() async throws {
+        // Custom error types for testing
+        struct MyCustomError: Error {
+            let message: String
+        }
+
+        enum MyEnumError: Error {
+            case anotherCase(String)
+        }
+
+        struct ErrorReportingBehavior: LambdaServerBehavior {
+            let requestId = UUID().uuidString
+            let event = "error-testing"
+            let expectedErrorType: String
+
+            func getInvocation() -> GetInvocationResult {
+                .success((self.requestId, self.event))
+            }
+
+            func processResponse(requestId: String, response: String?) -> Result<String?, ProcessResponseError> {
+                Issue.record("should not process response, expecting error report")
+                return .failure(.internalServerError)
+            }
+
+            func processError(requestId: String, error: ErrorResponse) -> Result<Void, ProcessErrorError> {
+                #expect(self.requestId == requestId)
+                #expect(
+                    error.errorType == self.expectedErrorType,
+                    "Expected errorType '\(self.expectedErrorType)' but got '\(error.errorType)'"
+                )
+                return .success(())
+            }
+
+            func processInitError(error: ErrorResponse) -> Result<Void, ProcessErrorError> {
+                Issue.record("should not report init error")
+                return .failure(.internalServerError)
+            }
+        }
+
+        // Test with MyCustomError
+        try await withMockServer(behaviour: ErrorReportingBehavior(expectedErrorType: "MyCustomError")) { port in
+            let configuration = LambdaRuntimeClient.Configuration(ip: "127.0.0.1", port: port)
+
+            try await LambdaRuntimeClient.withRuntimeClient(
+                configuration: configuration,
+                eventLoop: NIOSingletons.posixEventLoopGroup.next(),
+                logger: self.logger
+            ) { runtimeClient in
+                let (_, writer) = try await runtimeClient.nextInvocation()
+                let error = MyCustomError(message: "Something went wrong")
+                try await writer.reportError(error)
+            }
+        }
+
+        // Test with MyEnumError
+        try await withMockServer(behaviour: ErrorReportingBehavior(expectedErrorType: "MyEnumError")) { port in
+            let configuration = LambdaRuntimeClient.Configuration(ip: "127.0.0.1", port: port)
+
+            try await LambdaRuntimeClient.withRuntimeClient(
+                configuration: configuration,
+                eventLoop: NIOSingletons.posixEventLoopGroup.next(),
+                logger: self.logger
+            ) { runtimeClient in
+                let (_, writer) = try await runtimeClient.nextInvocation()
+                let error = MyEnumError.anotherCase("test")
+                try await writer.reportError(error)
+            }
+        }
+    }
 }