Adds two new methods on the StringCmdable interface that let callers read
and write Redis string values directly into/from pre-allocated byte
buffers, eliminating the per-call payload allocation that the regular
Get/Set methods incur.

Public API:
  GetToBuffer(ctx, key, buf) *ZeroCopyStringCmd
  SetFromBuffer(ctx, key, buf) *StatusCmd
  ZeroCopyStringCmd { Val() int; Bytes() []byte; Result() (int, error) }

Available on *Client, *ClusterClient, *Ring, *Conn and Pipeliner via

ReadLine() returns a slice into bufio.Reader's internal buffer (the
ReadSlice fast path). The follow-up io.ReadFull / Discard calls on
r.rd can trigger bufio.fill(), which copies new source bytes over the
slot line[0] used to point at. The post-read

    if line[0] == RespVerbatim { ... }

check on line 520 of reader.go could therefore observe a refilled byte
rather than the original response type. When that refilled byte
happened to be '=' (0x3D, RespVerbatim) — for example the head of a
bulk-string payload whose tail forced the refill — a regular `$<n>...`
Fix: capture line[0] into a local `isVerbatim` boolean before any
further read on r.rd, and use that local for both the pre-read length
check and the post-read prefix-stripping branch.

Regression test (internal/proto/reader_test.go): a payload sized to
exactly DefaultBufferSize, all '=' bytes. After ReadLine consumes the
header, bufio holds (bufsize - headerLen) payload bytes; the final
headerLen bytes io.ReadFull asks for force bufio.fill(), which places
payload-tail + trailing \r\n at position 0 of bufio.buf — i.e.
'=' at the slot line[0] points at. Against the buggy code the test
fails with n=32764 wanted 32768; with the fix all 10 ReadStringInto
tests pass.

Three related cleanups to ReadStringInto and the cmd it backs:

1. Buffer-too-small now drains the unread payload + trailing CRLF before
   returning the error, so the underlying connection stays aligned for
   the next reply. Without this drain, a too-small caller buffer left
   the bulk payload sitting in the bufio stream — the connection would
   then be returned to the pool in a corrupted state, and the next user
   of that connection would parse the leftover bytes as a malformed
   response. The existing test only checked the first call's error and
   missed this; it now feeds two consecutive bulk-string replies and
   asserts the second parses cleanly. Verified failure-mode by reverting
   just the drain: the follow-up read fails with
   `can't parse reply="hello" reading string into buffer`.

2. Drop RespVerbatim handling from ReadStringInto. The only public
   caller is GetToBuffer, which issues GET, and GET never returns a
   verbatim string — RESP3 verbatim replies come from server-info
   commands like CLIENT INFO / DEBUG OBJECT / LOLWUT. Keeping the
   branch re-introduces a hazard class where the response-type byte
   read from a stale line[0] after a bufio refill can be misinterpreted
   as the verbatim format tag (the bug fixed in
   "fix(proto): avoid stale line[0] after bufio refill in ReadStringInto").
   Removing the branch eliminates the class structurally and drops an
   O(n) memmove on the verbatim path (`copy(buf, buf[4:n])`).

   The unit test that previously asserted verbatim parsing is reshaped
   to assert verbatim now surfaces as an error, and the
   BulkStringStartingWithEqRefill regression test is kept (and its
   comment updated) as a guard against re-introducing verbatim support
   without re-introducing the bug.

3. Add a godoc paragraph to ZeroCopyStringCmd.Clone explaining the
   deep-copy semantics (clone gets a freshly allocated buffer, not a
   slice of the caller's memory) and noting that Clone is unreachable
   through normal client flows: it is only called from cluster fan-out
   routing in osscluster_router.go for multi-shard commands like
   DBSIZE / KEYS / FLUSHDB, and ZeroCopyStringCmd is only produced by
   GetToBuffer which issues GET — a single-key command never fanned
   out. Combined with NoRetry()=true blocking the retry path, Clone
   exists only to satisfy the Cmder interface and to keep the cmd usable
   if a future caller does fan out.