Add MarshalINI and UnmarshalINI for custom key values - #427

Describe the pull request

Types can now format and parse their own key values:

type Marshaler interface {
	MarshalINI() ([]byte, error)
}

type Unmarshaler interface {
	UnmarshalINI([]byte) error
}

Where they apply

• Reading: MapTo and StrictMapTo call UnmarshalINI with the value as Key.String returns it, for a plain field, a pointer field, and each element of a slice field. List, ValidList, StrictList, In and Range call it too for a Scalar type, so ini.List[Permission](k, ",") works for a named int enum.
• Writing: ReflectFrom calls MarshalINI for the same kinds of field, with either a value or a pointer receiver.
• Errors: an error from UnmarshalINI is handled like a value that doesn't parse. MapTo leaves a field unchanged and makes a failing slice element the zero value. StrictMapTo and StrictList return the error. ReflectFrom returns an error from MarshalINI.

Rules

1. A string, boolean or number type uses whichever method it implements, and its kind handles the other direction. A named int enum with UnmarshalINI reads Perm = write instead of failing on a non-number.
2. Any other type, such as a struct, slice or map type, maps to one key only when it implements both methods, so a type such as a host:port pair can be one value. With only one of them, a struct still maps to a section, a slice to a list, and other types stay unsupported, in both directions. A struct that embeds a type with both methods gets them, and so maps to one key too. Where sections are asked for explicitly, by a nonunique field or a value passed to a section of a file with AllowNonUniqueSections, any struct type still maps to sections.
3. time.Time keeps its own handling.

Tests

• TestMarshalerUnmarshaler covers an enum and a struct type: reading, writing and reading back, errors in MapTo, StrictMapTo and ReflectFrom, and the generic accessors. A fifth subtest checks that slice, struct and map types with only one method keep their usual mapping. Each subtest fails without the change it covers.
• TestStructMappingMatrix maps a number, struct, slice, map and array type, each with no methods, either method, or both, in every field shape: plain, pointer, pointer to pointer, slice, array, interface, allowshadow, delim, in a section, nonunique, embedded, extends, and passed for a section. Each must round trip through ReflectFrom, Write and MapTo, or be unsupported in both directions. The rows for types without both methods match v2. Two cases are written but not read, as on v2, and the test expects exactly those: a pointer to a slice, and a pointer to a pointer.
• FuzzStructMapping now has enum, custom struct, slice and map fields, and custom nonunique sections. A 45-second run found nothing.

Link to the issue: #353

Checklist

• I agree to follow the Code of Conduct by submitting this pull request.
• I have read and acknowledge the Contributing guide.
• I have added test cases to cover the new code.

AI usage

Claude Code ran the self-review (bugs, docs, security and repository rules, each by a separate review agent) and wrote the follow-up commits 68f90c3, d679f6c, 346a07c, f838383, 2a7d2c1, 9a4d4b8 and the revert of the last two's read support, which fix the one-method slice, struct, map and array cases, custom struct types where sections are asked for, and the doc inaccuracies those reviews found, and add the matrix test.