fix: Improve jwriter throughput with append-based buffer internals

[kinyoklion]

SDK-2878 — backport of #51 to v3.

Rewrites the default token writer's internals around an append-based byte slice, the same design encoding/json adopted in Go 1.19–1.24: streamableBuffer holds a plain []byte written with inlinable appends, the string escape scan appends clean segments in a single pass, numbers append via strconv directly into the buffer, and the streaming chunk-size check runs once per token instead of once per fragment. Buffer growth at least doubles capacity so reallocations stay logarithmic; Flush returns and records destination errors, detects short writes, and never retains undelivered data; MarshalJSONWithWriter starts from a pre-sized buffer. Public API and encoded output are unchanged (chunk boundaries in streaming mode move to token granularity; total output is identical).

Adaptations for v3

The change is otherwise verbatim from v4; three things differ because v3 still ships the easyjson build-tag variant:

• The default-implementation build tags and header comment are preserved on token_writer_default.go.
• The two buffer-internals tests (growth amortization, marshal allocations) live in a new default-tagged file, because v3 compiles the shared test files under both tags and they reference default-only internals.
• token_writer_easyjson.go gains the equivalent pre-sized constructor (EnsureSpace) so the shared marshal entry point compiles under both tags.

Validation

Full suite green under both build tags, plus -race; lint clean (default tags, matching CI). Benchmarks on v3 (linux/amd64, interleaved binaries, benchstat n=4, listed deltas p=0.029; encoding/json comparatives in the same runs were flat):

WriteString                    -27.1%
WriteArrayOfBools              -21.3%
WriteArrayOfStrings            -46.9%
WriteObject                    -31.6%
StreamingWriterArrayOfStrings  -33.3%

On a real 3,228-flag / 3.2 MB LaunchDarkly payload marshaled through ldmodel (go-server-sdk-evaluation v3, which consumes this module natively): in-memory whole-environment marshal 10.2 ms → 8.4 ms (-17.6%), streaming with an 8 KiB chunk size 10.3 ms → 6.9 ms (-33.5%).

The byte-class-table scan backport (#57) builds on this branch and merges after it.

---

Note

Overview
Rewrites the default jwriter token path around an append-based []byte streamableBuffer instead of bytes.Buffer, with at-least-doubling growth, pre-sized writers (64-byte default, 1000 for MarshalJSONWithWriter), and direct strconv appends for numbers.

String escaping uses a plainStringChars lookup table and segment appends (no per-rune UTF-8 walk); streaming mode flushes at chunk boundaries while scanning so escape-heavy strings do not grow the buffer with input length.

Streaming reliability: Flush detects short writes (io.ErrShortWrite), sticks destination errors, drops undelivered buffered data, and Writer.Flush records those errors on the writer; chunk flush timing aligns with completed tokens (total output unchanged).

v3 easyjson build: adds matching newTokenWriterWithCapacity / EnsureSpace; buffer-internals tests live in default-tagged files only.

Tests cover growth panics, reallocation bounds, marshal allocation budget, destination failures, short writes, parity across chunk sizes, and escape-heavy streaming bounds.

^{Reviewed by Cursor Bugbot for commit 18671e7. Bugbot is set up for automated code reviews on this repo. Configure here.}