feat: Go 1.24 omitzero struct tag support

[bouroo]

Summary

Adds support for the omitzero struct tag option, aligned with the omitzero
semantics encoding/json introduced in Go 1.24: a field is omitted when its
value is the zero value for its type unlike omitempty, which also drops
empty-but-non-nil collections.

type T struct {
    A int       `json:"a,omitzero"` // omitted when 0
    B []int     `json:"b,omitzero"` // omitted only when nil `[]int{}` is kept
    C *int      `json:"c,omitzero"` // omitted only when nil ptr-to-0 is kept
    D time.Time `json:"d,omitzero"` // omitted when IsZero() reports zero
}

Field value	omitempty	omitzero
0, "", false	omitted	omitted
nil slice / map / pointer	omitted	omitted
empty non-nil slice []int{} / map map[string]int{}	omitted	kept
non-nil pointer to zero (new(int))	kept	kept
time.Time{} (or any IsZero() bool type)	kept	omitted

Implementation

• Three new opcodes OpStructHeadOmitZero, OpStructPtrHeadOmitZero,
  OpStructFieldOmitZero route any omitzero-tagged field regardless of
  kind (struct-end optimization is skipped for such fields).
• internal/encoder/omitzero.go: IsZeroForOmitZero dispatches on the field
  kind primitives are read directly without reflection; struct and array
  kinds fall back to reflect, honoring a custom IsZero() bool (so time.Time
  and user-defined zeroers work, including marshaler-typed fields).
• The VM template (vm.go.tmpl, regenerated into all four VM variants) handles
  both slot layouts:
  • indirect (IndirectFlags set): the slot holds a struct base; map-kind
    includes store the map value (ptrToPtr(p+offset)) as OpMap requires;
  • direct interface (pointer-shaped struct passed by value): the slot
    holds the field value itself maps store the value, every other kind
    stores &slot (ctxptr+code.Idx), matching the dereference contracts of
    OpPtr/OpIntPtr/OpSlice.
• Unsafe access uses the *(*T)(unsafe.Pointer(&p)) double-deref idiom already
  used throughout internal/encoder/vm/util.go: it never converts a uintptr
  to unsafe.Pointer directly, so it passes go vet's unsafeptr check and the
  race detector's checkptr validation without any suppression directives.
• Decoder side: the tag is accepted when unmarshaling; decode behavior is
  unchanged.

Also included: minor cleanups min/max renamed to minAddr/maxAddr in
internal/runtime/type.go (avoids shadowing the builtins), and static
fmt.Errorf calls replaced with errors.New.

Testing

omitzero_test.go adds 40 subtests plus a benchmark, including regression
classes for the tricky encoding paths:

• pointer-shaped (direct-interface) structs marshaled by value single
  map/slice/pointer fields (nil, empty-non-nil, non-empty)
• struct-pointer (*T) marshals: nil → null, zero struct → {}
• field-level (non-head) map includes and pointer-marshal map heads
• custom IsZero() bool implementations whose zero disagrees with
  reflect.Value.IsZero, and time.Time zero/non-zero
• omitempty vs omitzero side-by-side and mixed-tag structs

---

resolve #539 , closed #562