common interfaces for marshaling primitive kinds

[dsnet]

The inspiration for this is #54582.

Adding MarshalJSON methods would work, but is not performant since we would always be allocating, which is unfortunate.

Alternative, these types could implement:

func (x *Int64) MarshalNextJSON(mo json.MarshalOptions, enc *jsontext.Encoder) error { ... }

However, this would cause the atomic package to have a dependency on both the json and jsontext packages, which is unreasonable.

I wonder if we should support something like:

type BoolMarshaler  interface { MarshalBool() (bool, error) }
type IntMarshaler   interface { MarshalInt() (int64, error) }
type UintMarshaler  interface { MarshalUint() (uint64, error) }
type FloatMarshaler interface { MarshalFloat() (float64, error) }

type BoolUnmarshaler  interface { UnmarshalBool(bool) error }
type IntUnmarshaler   interface { UnmarshalInt(int64) error }
type UintUnmarshaler  interface { UnmarshalUint(uint64) error }
type FloatUnmarshaler interface { UnmarshalFloat(float64) error }

Alternatively, we could even have:

type ScalarMarshaler[T bool | int64 | uint64 | float64]   interface { MarshalScalar() (T, error) }
type ScalarUnmarshaler[T bool | int64 | uint64 | float64] interface { UnmarshalScalar(T) error }

With the generics approach, all methods share the same name, but my have different types that it operates on. Perhaps this is a feature since it forces a given type to only implement MarshalScalar for one type. We wouldn't have to define the behavior for when MarshalInt and MarshalUint are both present.

[dsnet]

Ooops. This was meant to go in a different repo.