Apply naming convention to nested structs with dynamorm:"json" tag

Updates marshalComplexValue to use the same naming convention logic as
top-level fields when marshaling nested structs. This ensures consistent
camelCase field names throughout the DynamoDB document.

Previously, nested structs with the dynamorm:"json" tag would use Go
struct field names directly (PascalCase), while top-level fields were
converted to camelCase. Now both follow the same pattern:

1. Apply naming convention (e.g., PascalCase → camelCase)
2. Override with json tag if present

Example:
- Field: IsInstructionallyFunded
- Naming convention: isInstructionallyFunded
- With json:"is_funded": is_funded (tag overrides convention)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: JeffersonSchuler

pkg/marshal/marshaler.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
 	"github.com/pay-theory/dynamorm/pkg/model"
+	"github.com/pay-theory/dynamorm/pkg/naming"
 	pkgTypes "github.com/pay-theory/dynamorm/pkg/types"
 )
 
@@ -20,6 +21,8 @@ type Marshaler struct {
 	cache sync.Map // map[reflect.Type]*structMarshaler
 	// Optional custom converter registry shared with DB
 	converter *pkgTypes.Converter
+	// Naming convention for nested structs (defaults to CamelCase)
+	namingConvention naming.Convention
 }
 
 // structMarshaler contains cached information for marshaling a specific struct type
@@ -80,6 +83,11 @@ func (m *Marshaler) MarshalItem(model any, metadata *model.Metadata) (map[string
 		return nil, fmt.Errorf("model must be a struct or pointer to struct")
 	}
 
+	// Set naming convention from metadata for nested struct marshaling
+	if metadata != nil {
+		m.namingConvention = metadata.NamingConvention
+	}
+
 	// Get or create cached marshaler
 	typ := v.Type()
 	cached, ok := m.cache.Load(typ)
@@ -426,23 +434,24 @@ func (m *Marshaler) marshalComplexValue(v reflect.Value) (types.AttributeValue,
 				return nil, fmt.Errorf("struct field %s: %w", field.Name, err)
 			}
 
-			// Parse JSON tag to get the field name
-			fieldName := field.Name
+			// Use same logic as top-level fields: naming convention first, then override with json tag if present
+			fieldName := naming.ConvertAttrName(field.Name, m.namingConvention)
+
+			// Check for json tag override
 			if jsonTag := field.Tag.Get("json"); jsonTag != "" && jsonTag != "-" {
-				// Handle json tag with options like "fieldname,omitempty"
-				if commaIdx := 0; commaIdx < len(jsonTag) {
-					for j, c := range jsonTag {
-						if c == ',' {
-							commaIdx = j
-							break
-						}
-					}
-					if commaIdx > 0 {
-						fieldName = jsonTag[:commaIdx]
-					} else if jsonTag != "" {
-						fieldName = jsonTag
+				// Parse json tag, handling options like "fieldname,omitempty"
+				commaIdx := -1
+				for j, c := range jsonTag {
+					if c == ',' {
+						commaIdx = j
+						break
 					}
 				}
+				if commaIdx > 0 {
+					fieldName = jsonTag[:commaIdx]
+				} else {
+					fieldName = jsonTag
+				}
 			}
 
 			structMap[fieldName] = av