Emit slog attributes from every handler (closes #19)

The handlers took attributes and dropped them on the floor. Handle never
read record.Attrs, so the inline slog.Info("casting", "device", d) form
lost its fields; WithAttrs returned the receiver unchanged, so anything
attached to a derived logger vanished; and WithGroup did the same, so
grouping silently did nothing. The JSON and webhook handlers marshaled
the slog.Record value directly, which cannot work: a record keeps its
attributes in unexported fields, so encoding/json only ever saw Time,
Message, Level and PC.

The consequence was perverse. Converting log.Printf("[%s] Casting %s",
device, file) into structured attributes, as the Go styleguide asks,
left the output with strictly less information than before, and the
calling code reviewed as correct because it was correct.

A small shared attribute layer now holds the accumulated attributes and
open groups. It is copy-on-write, so two loggers derived from one parent
cannot leak attributes into each other, and it qualifies attributes by
the groups open at the time they were attached, per the slog.Handler
contract. Rendering follows each handler's format: the JSON and webhook
handlers emit attributes as object fields with groups as nested objects,
merging a group named twice rather than duplicating its key; the console
handler appends key=value pairs, groups flattened to dotted keys, quoted
only where a bare value would be ambiguous.

Values the caller logged go into the json payload by reference, because
rendering only reads them, which leaves the group merge as the one place
a value already in the payload is written to. It merges only into the
unexported groupMap type this package allocates for its own groups: a
caller's map[string]any is a different type and can never satisfy that
type assertion, so it is replaced rather than written into. The
invariant holds by construction - nothing reachable from the caller is
modified by logging it.

Values are resolved through slog.Value.Resolve, so LogValuer values are
reported as the value they stand for instead of as a struct, and errors
are reported as their message rather than as the empty object
encoding/json makes of them. Anything encoding/json cannot marshal falls
back to its slog string form rather than rendering as an empty object.

A duration is nanoseconds as a number in the json and webhook payloads,
matching slog.NewJSONHandler, so a consumer can compare and aggregate
the field without parsing it first. The console line keeps the readable
"3s" form, matching slog.NewTextHandler, because a person reads that
one.

The record's own fields keep the names they have always had - Time,
Level, Message, PC - and win a collision with an attribute key, so
existing consumers of the json output see no change beyond the added
fields. That, and a repeated key keeping its last value, are the two
ways an attribute can go missing from the json output; both are now
written down in the README rather than left to be discovered.

All three handlers are covered, including WebhookHandler, which had the
same defect and is reached through the same MultiplexHandler.

README.md

@@ -18,6 +18,13 @@ Released v1.0.0 2024-06-14.  Works as intended.  No known bugs.
 -   if output is a tty, outputs pretty color logs
 -   if output is not a tty, outputs json
 -   supports delivering each log message via a webhook
+-   emits every `slog` attribute: those passed to a log call, those
+    accumulated with `WithAttrs`, and those qualified by `WithGroup`.
+    `slog.Group` values nest, and `slog.LogValuer` values are resolved. In
+    json output attributes are object fields (groups become nested objects);
+    in console output they are appended as `key=value` pairs, with grouped
+    keys written as `group.key=value`. See
+    [Attribute output](#attribute-output) for the details worth knowing
 
 ## Planned Features
 
@@ -60,6 +67,40 @@ func main() {
 }
 ```
 
+## Attribute output
+
+Attributes reach every handler: the ones passed to the log call, the ones
+accumulated with `WithAttrs`, and the ones qualified by the groups open at
+the time they were attached. `slog.Group` values nest, and
+`slog.LogValuer` values are resolved to the value they stand for. A few
+behaviours are worth knowing before you rely on them.
+
+**Your values are never modified.** Whatever you log is read and rendered,
+never written to. A map or a slice you pass to `slog.Any` comes back from
+the logger exactly as you handed it over, even when a group later uses the
+same key.
+
+**Durations are nanoseconds in json, and readable on the console.** The
+json and webhook payloads emit a `slog.Duration` as a number of
+nanoseconds, matching `slog.NewJSONHandler`, so a consumer can compare and
+aggregate the field without parsing it. The console line emits the same
+duration as `3s`, matching `slog.NewTextHandler`, because a person reads
+it.
+
+**The json payload is an object, with the consequences an object has.**
+The record's own fields are named `Time`, `Level`, `Message` and `PC`, and
+they own those names: an attribute keyed after one of them is dropped from
+the json and webhook output. A key logged more than once keeps its last
+value there for the same reason. Neither applies to the console output,
+which is a line of text: both pairs appear, in order. If you need a field
+called `message`, pick a key that does not collide - the collision is
+silent.
+
+**Empty things follow the `slog.Handler` contract.** An empty `Attr` is
+ignored, an empty group is elided along with its key, a group with an
+empty key is inlined into its parent, and `WithGroup("")` returns the
+handler unchanged.
+
 ## License
 
 [WTFPL](./LICENSE)