refactor(go): refactor go error processing (#3069)

## Why?

The Go serializer interface methods previously returned `error` values,
requiring error checking at every call site. This pattern was
inconsistent with the C++ implementation and led to verbose, repetitive
error handling code throughout the codebase.

## What does this PR do?

Refactors Go error handling to use a **centralized delayed error
pattern**, similar to the C++ implementation:

### Interface Changes
- **Serializer interface** methods no longer return `error`:
- `Write(ctx *WriteContext, refMode RefMode, writeType bool, value
reflect.Value)`
  - `WriteData(ctx *WriteContext, value reflect.Value)`
- `Read(ctx *ReadContext, refMode RefMode, readType bool, value
reflect.Value)`
- `ReadData(ctx *ReadContext, type_ reflect.Type, value reflect.Value)`
- `ReadWithTypeInfo(ctx *ReadContext, refMode RefMode, typeInfo
*TypeInfo, value reflect.Value)`

### Error Handling Pattern
- Errors are set via `ctx.SetError(FromError(err))` or
`ctx.SetError(DeserializationErrorf(...))`
- Early return on error using `if ctx.HasError() { return }`
- Final error check at API boundaries via `ctx.CheckError()` or
`ctx.TakeError()`

### Files Modified
- **Serializer implementations**: array_primitive.go, map_primitive.go,
struct.go, skip.go
- **Context files**: reader.go, writer.go
- **Cleanup**: enum.go, slice_primitive.go (removed unused fmt imports)
- **Code generator**: codegen/generator.go, codegen/encoder.go,
codegen/decoder.go
- **Generated test file**: tests/structs_fory_gen.go

### Benefits
- Cleaner, more consistent code with less boilerplate
- Aligns with C++ implementation pattern
- Errors are accumulated in context and checked at API boundaries
- Reduces cognitive overhead when writing serializers

## Related issues

#2982 #3012

Closes #3026

## Does this PR introduce any user-facing change?

- [x] Does this PR introduce any public API change?
- Yes, the `Serializer` interface method signatures have changed (no
longer return `error`)
- This is an internal API change; the public `Fory.Serialize()` and
`Fory.Deserialize()` APIs remain unchanged
- [ ] Does this PR introduce any binary protocol compatibility change?
  - No, the wire format is unchanged

## Benchmark

No performance regression expected - this is a refactoring of error
handling flow, not serialization logic.

Author: chaokunyang

go/fory/array.go

@@ -24,48 +24,53 @@ import (
 // writeArrayRefAndType handles reference and type writing for array serializers.
 // Arrays are value types, so ref handling is simpler than slices.
 // Returns true if the value was already written, false if data should be written.
-func writeArrayRefAndType(ctx *WriteContext, refMode RefMode, writeType bool, value reflect.Value, typeId TypeId) (bool, error) {
+func writeArrayRefAndType(ctx *WriteContext, refMode RefMode, writeType bool, value reflect.Value, typeId TypeId) bool {
 	if refMode != RefModeNone {
 		// Arrays are value types, just write NotNullValueFlag
 		ctx.Buffer().WriteInt8(NotNullValueFlag)
 	}
 	if writeType {
 		ctx.Buffer().WriteVaruint32Small7(uint32(typeId))
 	}
-	return false, nil
+	return false
 }
 
 // readArrayRefAndType handles reference and type reading for array serializers.
 // Returns true if a reference was resolved (value already set), false if data should be read.
-func readArrayRefAndType(ctx *ReadContext, refMode RefMode, readType bool, value reflect.Value) (bool, error) {
+func readArrayRefAndType(ctx *ReadContext, refMode RefMode, readType bool, value reflect.Value) bool {
 	buf := ctx.Buffer()
+	err := ctx.Err()
 	if refMode != RefModeNone {
-		refID, err := ctx.RefResolver().TryPreserveRefId(buf)
-		if err != nil {
-			return false, err
+		refID, refErr := ctx.RefResolver().TryPreserveRefId(buf)
+		if refErr != nil {
+			ctx.SetError(FromError(refErr))
+			return false
 		}
 		if int8(refID) < NotNullValueFlag {
 			obj := ctx.RefResolver().GetReadObject(refID)
 			if obj.IsValid() {
 				value.Set(obj)
 			}
-			return true, nil
+			return true
 		}
 	}
 	if readType {
-		typeID := buf.ReadVaruint32Small7()
+		typeID := buf.ReadVaruint32Small7(err)
+		if ctx.HasError() {
+			return false
+		}
 		if IsNamespacedType(TypeId(typeID)) {
 			_, _ = ctx.TypeResolver().readTypeInfoWithTypeID(buf, typeID)
 		}
 	}
-	return false, nil
+	return false
 }
 
 // Array serializers
 
 type arraySerializer struct{}
 
-func (s arraySerializer) WriteData(ctx *WriteContext, value reflect.Value) error {
+func (s arraySerializer) WriteData(ctx *WriteContext, value reflect.Value) {
 	buf := ctx.Buffer()
 	length := value.Len()
 	buf.WriteVaruint32(uint32(length))
@@ -74,36 +79,35 @@ func (s arraySerializer) WriteData(ctx *WriteContext, value reflect.Value) error
 		buf.WriteInt8(NotNullValueFlag)
 		_ = elem
 	}
-	return nil
 }
 
-func (s arraySerializer) Write(ctx *WriteContext, refMode RefMode, writeType bool, value reflect.Value) error {
-	_, err := writeArrayRefAndType(ctx, refMode, writeType, value, -LIST)
-	if err != nil {
-		return err
+func (s arraySerializer) Write(ctx *WriteContext, refMode RefMode, writeType bool, value reflect.Value) {
+	writeArrayRefAndType(ctx, refMode, writeType, value, -LIST)
+	if ctx.HasError() {
+		return
 	}
-	return s.WriteData(ctx, value)
+	s.WriteData(ctx, value)
 }
 
-func (s arraySerializer) ReadData(ctx *ReadContext, type_ reflect.Type, value reflect.Value) error {
+func (s arraySerializer) ReadData(ctx *ReadContext, type_ reflect.Type, value reflect.Value) {
 	buf := ctx.Buffer()
-	length := int(buf.ReadVaruint32())
+	err := ctx.Err()
+	length := int(buf.ReadVaruint32(err))
 	for i := 0; i < length; i++ {
-		_ = buf.ReadInt8()
+		_ = buf.ReadInt8(err)
 	}
-	return nil
 }
 
-func (s arraySerializer) Read(ctx *ReadContext, refMode RefMode, readType bool, value reflect.Value) error {
-	done, err := readArrayRefAndType(ctx, refMode, readType, value)
-	if done || err != nil {
-		return err
+func (s arraySerializer) Read(ctx *ReadContext, refMode RefMode, readType bool, value reflect.Value) {
+	done := readArrayRefAndType(ctx, refMode, readType, value)
+	if done || ctx.HasError() {
+		return
 	}
-	return s.ReadData(ctx, value.Type(), value)
+	s.ReadData(ctx, value.Type(), value)
 }
 
-func (s arraySerializer) ReadWithTypeInfo(ctx *ReadContext, refMode RefMode, typeInfo *TypeInfo, value reflect.Value) error {
-	return s.Read(ctx, refMode, false, value)
+func (s arraySerializer) ReadWithTypeInfo(ctx *ReadContext, refMode RefMode, typeInfo *TypeInfo, value reflect.Value) {
+	s.Read(ctx, refMode, false, value)
 }
 
 // arrayConcreteValueSerializer serialize an array/*array
@@ -113,14 +117,14 @@ type arrayConcreteValueSerializer struct {
 	referencable   bool
 }
 
-func (s *arrayConcreteValueSerializer) WriteData(ctx *WriteContext, value reflect.Value) error {
+func (s *arrayConcreteValueSerializer) WriteData(ctx *WriteContext, value reflect.Value) {
 	length := value.Len()
 	buf := ctx.Buffer()
 
 	// Write length
 	buf.WriteVaruint32(uint32(length))
 	if length == 0 {
-		return nil
+		return
 	}
 
 	// Determine collection flags - same logic as slices
@@ -173,7 +177,8 @@ func (s *arrayConcreteValueSerializer) WriteData(ctx *WriteContext, value reflec
 	}
 	if IsNamespacedType(TypeId(internalTypeID)) {
 		if err := ctx.TypeResolver().WriteTypeInfo(buf, elemTypeInfo); err != nil {
-			return err
+			ctx.SetError(FromError(err))
+			return
 		}
 	} else {
 		buf.WriteVaruint32Small7(uint32(internalTypeID))
@@ -188,8 +193,9 @@ func (s *arrayConcreteValueSerializer) WriteData(ctx *WriteContext, value reflec
 		// Handle null values (only for pointer element types)
 		if hasNull && elem.IsNil() {
 			if trackRefs {
-				if err := s.elemSerializer.Write(ctx, RefModeTracking, false, elem); err != nil {
-					return err
+				s.elemSerializer.Write(ctx, RefModeTracking, false, elem)
+				if ctx.HasError() {
+					return
 				}
 			} else {
 				buf.WriteInt8(NullFlag)
@@ -199,39 +205,47 @@ func (s *arrayConcreteValueSerializer) WriteData(ctx *WriteContext, value reflec
 
 		// Write element
 		if trackRefs {
-			if err := s.elemSerializer.Write(ctx, RefModeTracking, false, elem); err != nil {
-				return err
+			s.elemSerializer.Write(ctx, RefModeTracking, false, elem)
+			if ctx.HasError() {
+				return
 			}
 		} else {
-			if err := s.elemSerializer.WriteData(ctx, elem); err != nil {
-				return err
+			s.elemSerializer.WriteData(ctx, elem)
+			if ctx.HasError() {
+				return
 			}
 		}
 	}
-	return nil
 }
 
-func (s *arrayConcreteValueSerializer) Write(ctx *WriteContext, refMode RefMode, writeType bool, value reflect.Value) error {
-	_, err := writeArrayRefAndType(ctx, refMode, writeType, value, -LIST)
-	if err != nil {
-		return err
+func (s *arrayConcreteValueSerializer) Write(ctx *WriteContext, refMode RefMode, writeType bool, value reflect.Value) {
+	writeArrayRefAndType(ctx, refMode, writeType, value, -LIST)
+	if ctx.HasError() {
+		return
 	}
-	return s.WriteData(ctx, value)
+	s.WriteData(ctx, value)
 }
 
-func (s *arrayConcreteValueSerializer) ReadData(ctx *ReadContext, type_ reflect.Type, value reflect.Value) error {
+func (s *arrayConcreteValueSerializer) ReadData(ctx *ReadContext, type_ reflect.Type, value reflect.Value) {
 	buf := ctx.Buffer()
-	length := int(buf.ReadVaruint32())
+	err := ctx.Err()
+	length := int(buf.ReadVaruint32(err))
 
 	var trackRefs bool
 	if length > 0 {
 		// Read collection flags (same format as slices)
-		collectFlag := buf.ReadInt8()
+		collectFlag := buf.ReadInt8(err)
+		if ctx.HasError() {
+			return
+		}
 
 		// Read element type info if present
 		if (collectFlag & CollectionIsSameType) != 0 {
 			if (collectFlag & CollectionIsDeclElementType) == 0 {
-				typeID := buf.ReadVaruint32()
+				typeID := buf.ReadVaruint32(err)
+				if ctx.HasError() {
+					return
+				}
 				// Read additional metadata for namespaced types
 				_, _ = ctx.TypeResolver().readTypeInfoWithTypeID(buf, typeID)
 			}
@@ -245,34 +259,32 @@ func (s *arrayConcreteValueSerializer) ReadData(ctx *ReadContext, type_ reflect.
 
 		// When tracking refs, the element serializer handles ref flags
 		if trackRefs {
-			if err := s.elemSerializer.Read(ctx, RefModeTracking, false, elem); err != nil {
-				return err
-			}
+			s.elemSerializer.Read(ctx, RefModeTracking, false, elem)
 		} else {
-			if err := s.elemSerializer.ReadData(ctx, elem.Type(), elem); err != nil {
-				return err
-			}
+			s.elemSerializer.ReadData(ctx, elem.Type(), elem)
+		}
+		if ctx.HasError() {
+			return
 		}
 	}
-	return nil
 }
 
-func (s *arrayConcreteValueSerializer) Read(ctx *ReadContext, refMode RefMode, readType bool, value reflect.Value) error {
-	done, err := readArrayRefAndType(ctx, refMode, readType, value)
-	if done || err != nil {
-		return err
+func (s *arrayConcreteValueSerializer) Read(ctx *ReadContext, refMode RefMode, readType bool, value reflect.Value) {
+	done := readArrayRefAndType(ctx, refMode, readType, value)
+	if done || ctx.HasError() {
+		return
 	}
-	if err := s.ReadData(ctx, value.Type(), value); err != nil {
-		return err
+	s.ReadData(ctx, value.Type(), value)
+	if ctx.HasError() {
+		return
 	}
 	if refMode != RefModeNone {
 		ctx.RefResolver().Reference(value)
 	}
-	return nil
 }
 
-func (s *arrayConcreteValueSerializer) ReadWithTypeInfo(ctx *ReadContext, refMode RefMode, typeInfo *TypeInfo, value reflect.Value) error {
-	return s.Read(ctx, refMode, false, value)
+func (s *arrayConcreteValueSerializer) ReadWithTypeInfo(ctx *ReadContext, refMode RefMode, typeInfo *TypeInfo, value reflect.Value) {
+	s.Read(ctx, refMode, false, value)
 }
 
 // arrayDynSerializer wraps sliceDynSerializer for arrays with interface element types.
@@ -289,26 +301,27 @@ func newArrayDynSerializer(elemType reflect.Type) (arrayDynSerializer, error) {
 	return arrayDynSerializer{sliceSerializer: sliceSer}, nil
 }
 
-func (s arrayDynSerializer) WriteData(ctx *WriteContext, value reflect.Value) error {
+func (s arrayDynSerializer) WriteData(ctx *WriteContext, value reflect.Value) {
 	// Convert array to slice and forward to sliceDynSerializer
 	slice := value.Slice(0, value.Len())
-	return s.sliceSerializer.WriteData(ctx, slice)
+	s.sliceSerializer.WriteData(ctx, slice)
 }
 
-func (s arrayDynSerializer) Write(ctx *WriteContext, refMode RefMode, writeType bool, value reflect.Value) error {
-	_, err := writeArrayRefAndType(ctx, refMode, writeType, value, LIST)
-	if err != nil {
-		return err
+func (s arrayDynSerializer) Write(ctx *WriteContext, refMode RefMode, writeType bool, value reflect.Value) {
+	writeArrayRefAndType(ctx, refMode, writeType, value, LIST)
+	if ctx.HasError() {
+		return
 	}
-	return s.WriteData(ctx, value)
+	s.WriteData(ctx, value)
 }
 
-func (s arrayDynSerializer) ReadData(ctx *ReadContext, _ reflect.Type, value reflect.Value) error {
+func (s arrayDynSerializer) ReadData(ctx *ReadContext, _ reflect.Type, value reflect.Value) {
 	// Create a temp slice to read into, then copy back to array
 	sliceType := reflect.SliceOf(value.Type().Elem())
 	tempSlice := reflect.MakeSlice(sliceType, value.Len(), value.Len())
-	if err := s.sliceSerializer.ReadData(ctx, sliceType, tempSlice); err != nil {
-		return err
+	s.sliceSerializer.ReadData(ctx, sliceType, tempSlice)
+	if ctx.HasError() {
+		return
 	}
 	// Copy elements from temp slice to array
 	copyLen := tempSlice.Len()
@@ -318,24 +331,23 @@ func (s arrayDynSerializer) ReadData(ctx *ReadContext, _ reflect.Type, value ref
 	for i := 0; i < copyLen; i++ {
 		value.Index(i).Set(tempSlice.Index(i))
 	}
-	return nil
 }
 
-func (s arrayDynSerializer) Read(ctx *ReadContext, refMode RefMode, readType bool, value reflect.Value) error {
-	done, err := readArrayRefAndType(ctx, refMode, readType, value)
-	if done || err != nil {
-		return err
+func (s arrayDynSerializer) Read(ctx *ReadContext, refMode RefMode, readType bool, value reflect.Value) {
+	done := readArrayRefAndType(ctx, refMode, readType, value)
+	if done || ctx.HasError() {
+		return
 	}
-	return s.ReadData(ctx, value.Type(), value)
+	s.ReadData(ctx, value.Type(), value)
 }
 
-func (s arrayDynSerializer) ReadWithTypeInfo(ctx *ReadContext, refMode RefMode, typeInfo *TypeInfo, value reflect.Value) error {
-	return s.Read(ctx, refMode, false, value)
+func (s arrayDynSerializer) ReadWithTypeInfo(ctx *ReadContext, refMode RefMode, typeInfo *TypeInfo, value reflect.Value) {
+	s.Read(ctx, refMode, false, value)
 }
 
 type byteArraySerializer struct{}
 
-func (s byteArraySerializer) WriteData(ctx *WriteContext, value reflect.Value) error {
+func (s byteArraySerializer) WriteData(ctx *WriteContext, value reflect.Value) {
 	buf := ctx.Buffer()
 	length := value.Len()
 	buf.WriteLength(length)
@@ -348,38 +360,40 @@ func (s byteArraySerializer) WriteData(ctx *WriteContext, value reflect.Value) e
 		}
 		buf.WriteBinary(data)
 	}
-	return nil
 }
 
-func (s byteArraySerializer) Write(ctx *WriteContext, refMode RefMode, writeType bool, value reflect.Value) error {
-	_, err := writeArrayRefAndType(ctx, refMode, writeType, value, BINARY)
-	if err != nil {
-		return err
+func (s byteArraySerializer) Write(ctx *WriteContext, refMode RefMode, writeType bool, value reflect.Value) {
+	writeArrayRefAndType(ctx, refMode, writeType, value, BINARY)
+	if ctx.HasError() {
+		return
 	}
-	return s.WriteData(ctx, value)
+	s.WriteData(ctx, value)
 }
 
-func (s byteArraySerializer) ReadData(ctx *ReadContext, type_ reflect.Type, value reflect.Value) error {
+func (s byteArraySerializer) ReadData(ctx *ReadContext, type_ reflect.Type, value reflect.Value) {
 	buf := ctx.Buffer()
-	length := buf.ReadLength()
+	err := ctx.Err()
+	length := buf.ReadLength(err)
+	if ctx.HasError() {
+		return
+	}
 	data := make([]byte, length)
 	buf.Read(data)
 	if value.CanSet() {
 		for i := 0; i < length && i < value.Len(); i++ {
 			value.Index(i).SetUint(uint64(data[i]))
 		}
 	}
-	return nil
 }
 
-func (s byteArraySerializer) Read(ctx *ReadContext, refMode RefMode, readType bool, value reflect.Value) error {
-	done, err := readArrayRefAndType(ctx, refMode, readType, value)
-	if done || err != nil {
-		return err
+func (s byteArraySerializer) Read(ctx *ReadContext, refMode RefMode, readType bool, value reflect.Value) {
+	done := readArrayRefAndType(ctx, refMode, readType, value)
+	if done || ctx.HasError() {
+		return
 	}
-	return s.ReadData(ctx, value.Type(), value)
+	s.ReadData(ctx, value.Type(), value)
 }
 
-func (s byteArraySerializer) ReadWithTypeInfo(ctx *ReadContext, refMode RefMode, typeInfo *TypeInfo, value reflect.Value) error {
-	return s.Read(ctx, refMode, false, value)
+func (s byteArraySerializer) ReadWithTypeInfo(ctx *ReadContext, refMode RefMode, typeInfo *TypeInfo, value reflect.Value) {
+	s.Read(ctx, refMode, false, value)
 }