perf: reuse one Utf8TextWriter for custom formatter bodies

Serialization allocated a Utf8TextWriter per event inside the batch loop on
the custom-ITextFormatter path -- 48 bytes each, ~47 KB of garbage per
1000-event batch. SerializationBuffers already caches the equivalent writer
for the message buffer; this adds the symmetric one over the body buffer.

Safe because Utf8TextWriter holds no state beyond its backing buffer (every
Write goes straight through, there is no internal buffering), that buffer is
already cleared per event, and SerializationBuffers is sink-owned and used
serially -- the same guarantee MessageWriter already relies on. Dropping the
`use` costs nothing: Utf8TextWriter does not override Dispose, so a formatter
retaining the reference is exactly as protected as before.

CustomFormatterSinkBenchmarks, Push(EventCount: 1000):

  Payload=Simple      116.03 KB -> 69.37 KB   (-40.2%)
  Payload=Exception  7573.80 KB -> 7519.11 KB  (-0.7%, exception rendering dominates)

Covered by the existing batch test, which drives a custom formatter across
four events and would fail if the reused writer carried state between them.

Refs #349

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: mishamyte

src/Serilog.Sinks.Grafana.Loki/Serialization.fs

@@ -33,6 +33,7 @@ type internal SerializationBuffers() =
 
     let bodyWriter = JsonWriterDefaults.createWriter body
     let messageWriter = new Utf8TextWriter(message)
+    let bodyTextWriter = new Utf8TextWriter(body)
 
     /// Envelope buffer holding the full push payload; read by LokiPushContent after serialize.
     member _.Main = main
@@ -42,11 +43,16 @@ type internal SerializationBuffers() =
     member _.BodyWriter = bodyWriter
     /// Reused writer for rendering each event's message to UTF-8.
     member _.MessageWriter = messageWriter
+    /// Reused TextWriter over the body buffer, handed to a custom ITextFormatter.
+    /// Utf8TextWriter holds no state of its own, so clearing Body between events is
+    /// the only reset needed — see the custom-formatter branch in serialize.
+    member _.BodyTextWriter = bodyTextWriter
 
     interface IDisposable with
         member _.Dispose() =
             (bodyWriter :> IDisposable).Dispose()
             (messageWriter :> IDisposable).Dispose()
+            (bodyTextWriter :> IDisposable).Dispose()
             (main :> IDisposable).Dispose()
             (body :> IDisposable).Dispose()
             (message :> IDisposable).Dispose()
@@ -131,11 +137,12 @@ module internal Serialization =
                 // Body: built-in fast path writes JSON straight to bodyBuffer (via the reused
                 // writer); a custom ITextFormatter writes text through Utf8TextWriter. Either way
                 // bodyBuffer then holds the UTF-8 body, which becomes the 2nd "values" element.
+                // Both writers are owned by buffers and reused across the batch — Utf8TextWriter
+                // carries no state, so clearing bodyBuffer below is the whole reset.
                 if not (obj.ReferenceEquals(builtIn, null)) then
                     builtIn.FormatToBuffer(event, buffers.BodyWriter, buffers.MessageWriter)
                 else
-                    use textWriter = new Utf8TextWriter(buffers.Body)
-                    textFormatter.Format(event, textWriter)
+                    textFormatter.Format(event, buffers.BodyTextWriter)
 
                 // A formatter terminates the body the way a stream sink needs — Serilog's stock
                 // output templates render a trailing newline via {NewLine} or {Exception}. That is