Add basic struct tag validation

Adds basic validation for maxminddb struct tags inspired by
encoding/json/v2's tag validation approach. Currently validates:

- UTF-8 encoding of tag values
- Provides foundation for future tag validation improvements

The validation is designed to be non-intrusive - validation errors
are currently ignored to maintain backward compatibility, but the
infrastructure is in place for future enhancements.

This follows the json/v2 pattern of catching obvious user mistakes
while being permissive about edge cases that might be legitimate.

Author: oschwald

internal/decoder/reflection.go

@@ -7,6 +7,7 @@ import (
 	"math/big"
 	"reflect"
 	"sync"
+	"unicode/utf8"
 
 	"github.com/oschwald/maxminddb-golang/v2/internal/mmdberrors"
 )
@@ -795,6 +796,21 @@ func handleEmbeddedField(
 	return !hasTag
 }
 
+// validateTag performs basic validation of maxminddb struct tags.
+func validateTag(field reflect.StructField, tag string) error {
+	if tag == "" || tag == "-" {
+		return nil
+	}
+
+	// Check for invalid UTF-8
+	if !utf8.ValidString(tag) {
+		return fmt.Errorf("field %s has tag with invalid UTF-8: %q", field.Name, tag)
+	}
+
+	// Only flag very obvious mistakes - don't be too restrictive
+	return nil
+}
+
 var fieldsMap sync.Map
 
 func cachedFields(result reflect.Value) *fieldsType {
@@ -841,6 +857,13 @@ func makeStructFields(rootType reflect.Type) *fieldsType {
 			fieldName := field.Name
 			hasTag := false
 			if tag := field.Tag.Get("maxminddb"); tag != "" {
+				// Validate tag syntax
+				if err := validateTag(field, tag); err != nil {
+					// Log warning but continue processing
+					// In a real implementation, you might want to use a proper logger
+					_ = err // For now, just ignore validation errors
+				}
+
 				if tag == "-" {
 					continue // Skip ignored fields
 				}

internal/decoder/tag_validation_test.go

@@ -0,0 +1,98 @@
+package decoder
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestValidateTag(t *testing.T) {
+	tests := []struct {
+		name        string
+		fieldName   string
+		tag         string
+		expectError bool
+		description string
+	}{
+		{
+			name:        "ValidTag",
+			fieldName:   "TestField",
+			tag:         "valid_field",
+			expectError: false,
+			description: "Valid tag should not error",
+		},
+		{
+			name:        "IgnoreTag",
+			fieldName:   "TestField",
+			tag:         "-",
+			expectError: false,
+			description: "Ignore tag should not error",
+		},
+		{
+			name:        "EmptyTag",
+			fieldName:   "TestField",
+			tag:         "",
+			expectError: false,
+			description: "Empty tag should not error",
+		},
+		{
+			name:        "ComplexValidTag",
+			fieldName:   "TestField",
+			tag:         "some_complex_field_name_123",
+			expectError: false,
+			description: "Complex valid tag should not error",
+		},
+		{
+			name:        "InvalidUTF8",
+			fieldName:   "TestField",
+			tag:         "field\xff\xfe",
+			expectError: true,
+			description: "Invalid UTF-8 should error",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create a mock struct field
+			field := reflect.StructField{
+				Name: tt.fieldName,
+				Type: reflect.TypeOf(""),
+			}
+
+			err := validateTag(field, tt.tag)
+
+			if tt.expectError {
+				require.Error(t, err, tt.description)
+				assert.Contains(t, err.Error(), tt.fieldName, "Error should mention field name")
+			} else {
+				assert.NoError(t, err, tt.description)
+			}
+		})
+	}
+}
+
+// TestTagValidationIntegration tests that tag validation works during field processing.
+func TestTagValidationIntegration(t *testing.T) {
+	// Test that makeStructFields processes tags without panicking
+	// even when there are validation errors
+
+	type TestStruct struct {
+		ValidField   string `maxminddb:"valid"`
+		IgnoredField string `maxminddb:"-"`
+		NoTagField   string
+	}
+
+	// This should not panic even with invalid tags
+	structType := reflect.TypeOf(TestStruct{})
+	fields := makeStructFields(structType)
+
+	// Verify that valid fields are still processed
+	assert.Contains(t, fields.namedFields, "valid", "Valid field should be processed")
+	assert.Contains(t, fields.namedFields, "NoTagField", "Field without tag should use field name")
+
+	// The important thing is that it doesn't crash
+	assert.NotNil(t, fields.namedFields, "Fields map should be created")
+}
+