Fix CBOR codegen for recursive types by applying Box to union variants (#4116)

# Fix CBOR recursive data structure handling with Box implementation

This PR addresses an issue in the CBOR codegen where recursive union
data structures aren't properly boxed during deserialization, resulting
in uncompilable Rust code.

## Problem

The current CBOR implementation correctly defines recursive data
structures with `Box` in type definitions, but fails to apply the
corresponding `Box::new` wrapper during deserialization. This causes
type mismatches when deserializing recursive Smithy models.

For example, with this Smithy model:
```smithy
structure RecursiveOperationInputOutputNested1 {
    variant: FooChoice,
}
union FooChoice {
    choice1: String
    choice2: RecursiveOperationInputOutputNested1
}
```

The generated Rust type correctly uses `Box`:
```rust
pub enum FooChoice {
    Choice1(::std::string::String),
    Choice2(::std::boxed::Box<crate::model::RecursiveOperationInputOutputNested1>),
}
```

But the deserializer doesn't wrap the result with `Box::new`:
```rust
// In the deserializer function:
FooChoice::Choice2(
    crate::protocol_serde::shape_recursive_operation_input_output_nested1::de_recursive_operation_input_output_nested1(decoder)
?)
```

This leads to the compiler error:
```
error[E0308]: `?` operator has incompatible types
  --> shape_foo_choice.rs:14:9
   |
14 | /         crate::protocol_serde::shape_recursive_operation_input_output_nested1::de_recursive_operation_input_output_nested1(decoder)
15 | |     ?),
   | |_____^ expected `Box<RecursiveOperationInputOutputNested1>`, found `RecursiveOperationInputOutputNested1`
```

## Solution

This PR modifies the CBOR codegen to add `.map(Box::new)` when
deserializing values for union variants that are defined with `Box`. The
fixed code will generate:

```rust
FooChoice::Choice2(
    crate::protocol_serde::shape_recursive_operation_input_output_nested1::de_recursive_operation_input_output_nested1(decoder)
        .map(Box::new)?
)
```

This ensures type compatibility between the defined structure and the
deserialized data.

## Testing

Added a protocol test in `rpcv2Cbor-extras.smithy` file.

Closes: #4115

---------

Co-authored-by: Fahad Zubair <fahadzub@amazon.com>

Author: drganjoo

codegen-core/common-test-models/rpcv2Cbor-extras.smithy

@@ -15,6 +15,7 @@ service RpcV2CborService {
         ComplexStructOperation
         EmptyStructOperation
         SingleMemberStructOperation
+        RecursiveUnionOperation
     ]
 }
 
@@ -49,6 +50,11 @@ operation SingleMemberStructOperation {
     output: SingleMemberStruct
 }
 
+operation RecursiveUnionOperation {
+    input: RecursiveOperationInputOutput
+    output: RecursiveOperationInputOutput
+}
+
 apply EmptyStructOperation @httpMalformedRequestTests([
     {
         id: "AdditionalTokensEmptyStruct",
@@ -244,6 +250,52 @@ apply SimpleStructOperation @httpResponseTests([
     }
 ])
 
+apply RecursiveUnionOperation @httpResponseTests([
+    {
+        id: "RpcV2CborRecursiveShapesWithUnion",
+        documentation: "Serializes recursive structures with union",
+        protocol: rpcv2Cbor,
+        code: 200,
+        body: "v2ZuZXN0ZWS/Y2Zvb2RGb28xZ3ZhcmlhbnS/Z2Nob2ljZTFrT3V0ZXJDaG9pY2X/Zm5lc3RlZL9jYmFyZEJhcjFvcmVjdXJzaXZlTWVtYmVyv2Nmb29kRm9vMmd2YXJpYW50v2djaG9pY2Uyv2Nmb29kRm9vM2ZuZXN0ZWS/Y2JhcmRCYXIzb3JlY3Vyc2l2ZU1lbWJlcr9jZm9vZEZvbzRndmFyaWFudL9nY2hvaWNlMWtJbm5lckNob2ljZf//////Zm5lc3RlZL9jYmFyZEJhcjL//////w==",
+        bodyMediaType: "application/cbor",
+        headers: {
+            "smithy-protocol": "rpc-v2-cbor",
+            "Content-Type": "application/cbor"
+        },
+        params: {
+            nested: {
+                foo: "Foo1",
+                variant: {
+                    choice1: "OuterChoice"
+                },
+                nested: {
+                    bar: "Bar1",
+                    recursiveMember: {
+                        foo: "Foo2",
+                        variant: {
+                            choice2: {
+                                foo: "Foo3",
+                                nested: {
+                                    bar: "Bar3",
+                                    recursiveMember: {
+                                        foo: "Foo4",
+                                        variant: {
+                                            choice1: "InnerChoice"
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        nested: {
+                            bar: "Bar2"
+                        }
+                    }
+                }
+            }
+        }
+    }
+])
+
 structure ErrorSerializationOperationOutput {
     errorShape: ValidationException
 }
@@ -360,3 +412,23 @@ enum Suit {
     HEART
     SPADE
 }
+
+structure RecursiveOperationInputOutput {
+    nested: RecursiveOperationInputOutputNested1
+}
+
+structure RecursiveOperationInputOutputNested1 {
+    foo: String,
+    nested: RecursiveOperationInputOutputNested2,
+    variant: FooChoice,
+}
+
+structure RecursiveOperationInputOutputNested2 {
+    bar: String,
+    recursiveMember: RecursiveOperationInputOutputNested1,
+}
+
+union FooChoice {
+    choice1: String
+    choice2: RecursiveOperationInputOutputNested1
+}

codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/protocols/parse/CborParserGenerator.kt

@@ -366,6 +366,11 @@ class CborParserGenerator(
                         } else {
                             withBlock("${member.memberName.dq()} => #T::$variantName(", "?),", returnSymbolToParse.symbol) {
                                 deserializeMember(member).invoke(this)
+
+                                val symbol = symbolProvider.toSymbol(member)
+                                if (symbol.isRustBoxed()) {
+                                    rust(".map(Box::new)")
+                                }
                             }
                         }
                     }