Add binary marshal (#426)

Allow specifying directives for (external) types that support [BinaryMarshaler](https://pkg.go.dev/encoding#BinaryMarshaler) + [BinaryUnmarshaler](https://pkg.go.dev/encoding#BinaryUnmarshaler) and optionally [BinaryAppender](https://pkg.go.dev/encoding#BinaryAppender).

* `//msgp:binmarshal pkg.Type pkg.Type2` will use BinaryMarshaler/BinaryUnmarshaler. 
* `//msgp:binappend pkg.Type pkg.Type2` will use BinaryAppender/BinaryUnmarshaler.

Serialized data will be added an `bin` data, no special header.

I guess we could also add the text interfaces. But the user would probably need to specify the storage type...

* `//msgp:textmarshal pkg.Type pkg.Type2` will use TextMarshaler/TextUnmarshaler; data saved as bin (default)
* `//msgp:textappend pkg.Type pkg.Type2` will use TextAppender/TextUnmarshaler; data saved as bin (default)
* `//msgp:textmarshal as:string pkg.Type pkg.Type2` will use TextMarshaler/TextUnmarshaler; data saved as string. 
* `//msgp:textappend as:string pkg.Type pkg.Type2` will use TextAppender/TextUnmarshaler; data saved as string.

# Example

```
// BinaryTestType implements encoding.BinaryMarshaler and encoding.BinaryUnmarshaler
type BinaryTestType struct {
	Value string
}

//msgp:binmarshal BinaryTestType

func (t *BinaryTestType) MarshalBinary() ([]byte, error) {
	return []byte(t.Value), nil
}

func (t *BinaryTestType) UnmarshalBinary(data []byte) error {
	t.Value = string(data)
	return nil
}
```

# Implementation notes

Sizes are not accurate. We assume header + 32 bytes.

Author: klauspost

.github/workflows/test.yml

@@ -21,7 +21,7 @@ jobs:
   test:
     strategy:
       matrix:
-        go-version: [1.23.x, 1.24.x, 1.25.x]
+        go-version: [1.24.x, 1.25.x]
         os: [ubuntu-latest]
     runs-on: ${{ matrix.os }}
     timeout-minutes: 10

_generated/binary_marshaler.go

@@ -0,0 +1,289 @@
+package _generated
+
+import (
+	"encoding"
+	"fmt"
+)
+
+//go:generate msgp -v
+
+// BinaryTestType implements encoding.BinaryMarshaler and encoding.BinaryUnmarshaler
+type BinaryTestType struct {
+	Value string
+}
+
+func (t *BinaryTestType) MarshalBinary() ([]byte, error) {
+	return []byte(t.Value), nil
+}
+
+func (t *BinaryTestType) UnmarshalBinary(data []byte) error {
+	t.Value = string(data)
+	return nil
+}
+
+// Verify it implements the interfaces
+var _ encoding.BinaryMarshaler = (*BinaryTestType)(nil)
+var _ encoding.BinaryUnmarshaler = (*BinaryTestType)(nil)
+
+//msgp:binmarshal BinaryTestType
+
+// TextBinTestType implements encoding.TextMarshaler and encoding.TextUnmarshaler
+type TextBinTestType struct {
+	Value string
+}
+
+func (t *TextBinTestType) MarshalText() ([]byte, error) {
+	return []byte(fmt.Sprintf("text:%s", t.Value)), nil
+}
+
+func (t *TextBinTestType) UnmarshalText(data []byte) error {
+	t.Value = string(data[5:]) // Remove "text:" prefix
+	return nil
+}
+
+var _ encoding.TextMarshaler = (*TextBinTestType)(nil)
+var _ encoding.TextUnmarshaler = (*TextBinTestType)(nil)
+
+//msgp:textmarshal TextBinTestType
+
+// TextStringTestType for testing as:string option
+type TextStringTestType struct {
+	Value string
+}
+
+func (t *TextStringTestType) MarshalText() ([]byte, error) {
+	return []byte(fmt.Sprintf("stringtext:%s", t.Value)), nil
+}
+
+func (t *TextStringTestType) UnmarshalText(data []byte) error {
+	t.Value = string(data[11:]) // Remove "stringtext:" prefix
+	return nil
+}
+
+var _ encoding.TextMarshaler = (*TextStringTestType)(nil)
+var _ encoding.TextUnmarshaler = (*TextStringTestType)(nil)
+
+//msgp:textmarshal as:string TextStringTestType
+
+// TestStruct contains various combinations of marshaler types
+type TestStruct struct {
+	// Direct values
+	BinaryValue     BinaryTestType     `msg:"bin_val"`
+	TextBinValue    TextBinTestType    `msg:"text_bin_val"`
+	TextStringValue TextStringTestType `msg:"text_str_val"`
+
+	// Pointers
+	BinaryPtr     *BinaryTestType     `msg:"bin_ptr"`
+	TextBinPtr    *TextBinTestType    `msg:"text_bin_ptr,omitempty"`
+	TextStringPtr *TextStringTestType `msg:"text_str_ptr,omitempty"`
+
+	// Slices
+	BinarySlice     []BinaryTestType     `msg:"bin_slice"`
+	TextBinSlice    []TextBinTestType    `msg:"text_bin_slice"`
+	TextStringSlice []TextStringTestType `msg:"text_str_slice"`
+
+	// Arrays
+	BinaryArray     [3]BinaryTestType     `msg:"bin_array"`
+	TextBinArray    [2]TextBinTestType    `msg:"text_bin_array"`
+	TextStringArray [4]TextStringTestType `msg:"text_str_array"`
+
+	// Maps with marshaler types as values
+	BinaryMap     map[string]BinaryTestType     `msg:"bin_map"`
+	TextBinMap    map[string]TextBinTestType    `msg:"text_bin_map"`
+	TextStringMap map[string]TextStringTestType `msg:"text_str_map"`
+
+	// Nested pointers and slices
+	NestedPtrSlice []*BinaryTestType           `msg:"nested_ptr_slice"`
+	SliceOfArrays  [][2]TextBinTestType        `msg:"slice_of_arrays"`
+	MapOfSlices    map[string][]BinaryTestType `msg:"map_of_slices"`
+}
+
+//msgp:binmarshal ErrorTestType
+
+// ErrorTestType for testing error conditions
+type ErrorTestType struct {
+	ShouldError bool
+}
+
+func (e *ErrorTestType) MarshalBinary() ([]byte, error) {
+	if e.ShouldError {
+		return nil, fmt.Errorf("intentional marshal error")
+	}
+	return []byte("ok"), nil
+}
+
+func (e *ErrorTestType) UnmarshalBinary(data []byte) error {
+	if string(data) == "error" {
+		return fmt.Errorf("intentional unmarshal error")
+	}
+	e.ShouldError = false
+	return nil
+}
+
+// Test types for as:string positioning flexibility
+
+// TestTextMarshalerStringMiddle for testing as:string in middle of type list
+type TestTextMarshalerStringMiddle struct {
+	Value string
+}
+
+func (t *TestTextMarshalerStringMiddle) MarshalText() ([]byte, error) {
+	return []byte("middle:" + t.Value), nil
+}
+
+func (t *TestTextMarshalerStringMiddle) UnmarshalText(text []byte) error {
+	t.Value = string(text)
+	return nil
+}
+
+// TestTextMarshalerStringEnd for testing as:string at end of type list
+type TestTextMarshalerStringEnd struct {
+	Value string
+}
+
+func (t *TestTextMarshalerStringEnd) MarshalText() ([]byte, error) {
+	return []byte("end:" + t.Value), nil
+}
+
+func (t *TestTextMarshalerStringEnd) UnmarshalText(text []byte) error {
+	t.Value = string(text)
+	return nil
+}
+
+// TestTextAppenderStringPos for testing textappend with as:string positioning
+type TestTextAppenderStringPos struct {
+	Value string
+}
+
+func (t *TestTextAppenderStringPos) AppendText(dst []byte) ([]byte, error) {
+	return append(dst, []byte("append:"+t.Value)...), nil
+}
+
+func (t *TestTextAppenderStringPos) UnmarshalText(text []byte) error {
+	t.Value = string(text)
+	return nil
+}
+
+// BinaryAppenderType implements encoding.BinaryAppender (Go 1.22+)
+type BinaryAppenderType struct {
+	Value string
+}
+
+func (t *BinaryAppenderType) AppendBinary(dst []byte) ([]byte, error) {
+	return append(dst, []byte("binappend:"+t.Value)...), nil
+}
+
+func (t *BinaryAppenderType) UnmarshalBinary(data []byte) error {
+	t.Value = string(data)
+	return nil
+}
+
+// TextAppenderBinType implements encoding.TextAppender (stored as binary)
+type TextAppenderBinType struct {
+	Value string
+}
+
+func (t *TextAppenderBinType) AppendText(dst []byte) ([]byte, error) {
+	return append(dst, []byte("textbin:"+t.Value)...), nil
+}
+
+func (t *TextAppenderBinType) UnmarshalText(text []byte) error {
+	t.Value = string(text)
+	return nil
+}
+
+// ErrorBinaryAppenderType for testing error conditions with BinaryAppender
+type ErrorBinaryAppenderType struct {
+	ShouldError bool
+	Value       string
+}
+
+func (e *ErrorBinaryAppenderType) AppendBinary(dst []byte) ([]byte, error) {
+	if e.ShouldError {
+		return nil, fmt.Errorf("intentional append binary error")
+	}
+	return append(dst, []byte("ok")...), nil
+}
+
+func (e *ErrorBinaryAppenderType) UnmarshalBinary(data []byte) error {
+	if string(data) == "error" {
+		return fmt.Errorf("intentional unmarshal binary error")
+	}
+	e.ShouldError = false
+	e.Value = string(data)
+	return nil
+}
+
+// ErrorTextAppenderType for testing error conditions with TextAppender
+type ErrorTextAppenderType struct {
+	ShouldError bool
+	Value       string
+}
+
+func (e *ErrorTextAppenderType) AppendText(dst []byte) ([]byte, error) {
+	if e.ShouldError {
+		return nil, fmt.Errorf("intentional append text error")
+	}
+	return append(dst, []byte("ok")...), nil
+}
+
+func (e *ErrorTextAppenderType) UnmarshalText(text []byte) error {
+	if string(text) == "error" {
+		return fmt.Errorf("intentional unmarshal text error")
+	}
+	e.ShouldError = false
+	e.Value = string(text)
+	return nil
+}
+
+//msgp:binappend BinaryAppenderType ErrorBinaryAppenderType
+//msgp:textappend TextAppenderBinType ErrorTextAppenderType
+//msgp:textmarshal TestTextMarshalerStringMiddle as:string TestTextMarshalerStringEnd
+//msgp:textappend TestTextAppenderStringPos as:string
+
+//msgp:binappend BinaryAppenderValue
+
+// BinaryAppenderValue implements encoding.BinaryAppender (Go 1.22+)
+type BinaryAppenderValue struct {
+	Value string `msg:"-"`
+}
+
+func (t BinaryAppenderValue) AppendBinary(dst []byte) ([]byte, error) {
+	return append(dst, []byte("binappend:"+t.Value)...), nil
+}
+
+func (t *BinaryAppenderValue) UnmarshalBinary(data []byte) error {
+	t.Value = string(data)
+	return nil
+}
+
+//msgp:textappend TestAppendTextString as:string
+
+type TestAppendTextString struct {
+	Value string `msg:"-"`
+}
+
+func (t TestAppendTextString) AppendText(dst []byte) ([]byte, error) {
+	return append(dst, []byte("append:"+t.Value)...), nil
+}
+
+func (t *TestAppendTextString) UnmarshalText(text []byte) error {
+	t.Value = string(text)
+	return nil
+}
+
+//msgp:textappend TextAppenderBinValue
+
+// TextAppenderBinValue implements encoding.TextAppender (stored as binary)
+type TextAppenderBinValue struct {
+	Value string `msg:"-"`
+}
+
+func (t TextAppenderBinValue) AppendText(dst []byte) ([]byte, error) {
+	return append(dst, []byte("textbin:"+t.Value)...), nil
+}
+
+func (t *TextAppenderBinValue) UnmarshalText(text []byte) error {
+	t.Value = string(text)
+	return nil
+}