Fix go enum encoding (#1892)

Adds a test and fixes enums as members of structs
<!-- ELLIPSIS_HIDDEN -->

----

> [!IMPORTANT]
> Fixes Go enum encoding by updating pointer handling in
`generate_types.rs`, `decode.go`, and `types.go`, with a new test case
in `cffi_test.go`.
> 
>   - **Behavior**:
> - Fixes enum encoding in Go by updating `render_value_coercion` in
`generate_types.rs` to handle pointers correctly.
> - Modifies `decodePrimitiveValue` in `decode.go` to return pointers.
> - Updates `Decode` methods in `types.go` and `unions.go` to use
pointer dereferencing.
>   - **Tests**:
> - Adds a test case in `cffi_test.go` for `Person` struct to verify
enum encoding fix.
>   - **Misc**:
>     - Removes unnecessary type casting in `types.go` and `unions.go`.
> 
> <sup>This description was created by </sup>[<img alt="Ellipsis"
src="https://img.shields.io/badge/Ellipsis-blue?color=175173">](https://www.ellipsis.dev?ref=BoundaryML%2Fbaml&utm_source=github&utm_medium=referral)<sup>
for ca36789. You can
[customize](https://app.ellipsis.dev/BoundaryML/settings/summaries) this
summary. It will automatically update as commits are pushed.</sup>

<!-- ELLIPSIS_HIDDEN -->

Author: tberman

engine/language_client_codegen/src/go/generate_types.rs

@@ -55,25 +55,15 @@ pub(crate) fn cast_value(container_variable_name: &str, field_type: &GoType) ->
 
 fn render_value_coercion(container_variable_name: &str, field_type: &GoType) -> String {
     if field_type.is_pointer {
-        let inner_type = field_type.underlying_type.as_ref().unwrap();
         return format!(
             "func () {} {{
     val := baml.Decode({})
     if val == nil {{
         return nil
     }}
-    castVal := val.({})
-    return &castVal
+    return val.({})
 }}()",
-            field_type.name, container_variable_name, inner_type.name,
-        );
-    } else if field_type.is_class {
-        return format!(
-            "*baml.Decode({}).(*{})",
-            container_variable_name,
-            filters::type_name_without_pointer(&field_type.name)
-                .ok()
-                .unwrap()
+            field_type.name, container_variable_name, field_type.name,
         );
     } else if field_type.is_slice {
         let inner_type = field_type.underlying_type.as_ref().unwrap();
@@ -84,14 +74,9 @@ fn render_value_coercion(container_variable_name: &str, field_type: &GoType) ->
             inner_type.name,
             render_value_coercion("__holder", inner_type),
         );
-    } else if field_type.is_union {
-        return format!(
-            "*baml.Decode({container_variable_name}).(*{})",
-            field_type.name
-        );
     } else {
         return format!(
-            "baml.Decode({container_variable_name}).({})",
+            "*baml.Decode({container_variable_name}).(*{})",
             field_type.name
         );
     }

engine/language_client_go/pkg/decode.go

@@ -62,14 +62,15 @@ func (d *DynamicEnum) Decode(holder cffi.CFFIValueEnum) {
 	d.Value = string(holder.Value())
 }
 
-func decodePrimitiveValue[U any, T cffiValue[U]](valueHolder *cffi.CFFIValueHolder, t T) U {
+func decodePrimitiveValue[U any, T cffiValue[U]](valueHolder *cffi.CFFIValueHolder, t T) *U {
 	var tbl flatbuffers.Table
 	if !valueHolder.Value(&tbl) {
 		panic("error decoding value")
 	}
 
 	t.Init(tbl.Bytes, tbl.Pos)
-	return t.Value()
+	val := t.Value()
+	return &val
 }
 
 func decodeListValue(valueHolder *cffi.CFFIValueHolder) any {
@@ -396,8 +397,9 @@ func Decode(holder *cffi.CFFIValueHolder) any {
 	case cffi.CFFIValueUnionNONE:
 		return nil
 	case cffi.CFFIValueUnionCFFIValueString:
-		valueString := decodePrimitiveValue(holder, &cffi.CFFIValueString{})
-		return string(valueString)
+		valueBytes := decodePrimitiveValue(holder, &cffi.CFFIValueString{})
+		valueString := string(*valueBytes)
+		return &valueString
 	case cffi.CFFIValueUnionCFFIValueInt:
 		return decodePrimitiveValue(holder, &cffi.CFFIValueInt{})
 	case cffi.CFFIValueUnionCFFIValueFloat: