feat: add read_process_memory_into for zero-copy buffer reuse (#71)

[JeanExtreme002]

Summary

Closes #71.

read_process_memory allocates a fresh Python object on every call (a ctypes
buffer plus the returned bytes). In a long-running loop that polls the
same-sized region over and over — a recorder, a live overlay, a poller — those
throwaway objects create constant GC churn instead of constant memory use.

This adds read_process_memory_into(address, buffer) -> int, the zero-copy
counterpart of read_process_memory: it reads straight into a caller-owned,
reusable buffer with no intermediate allocation, and returns the number of
bytes read.

buffer = bytearray(4096)              # allocate once

with OpenProcess(name="game.exe") as process:
    while recording:
        process.read_process_memory_into(addr, buffer)
        handle(buffer)                # same buffer refilled in place — flat memory

How it works / why it fits the architecture

This is orthogonal to the existing optimizations, not a duplicate of them:

Mechanism	What it saves
snapshot_memory_regions / memory_regions=	region-map enumeration
search_by_addresses	number of syscalls (reads each page once)
read_process_memory_into (this PR)	per-read object allocation

• Accepts any writable, contiguous buffer-protocol object — bytearray,
  ctypes array, writable memoryview, numpy array (sized in bytes, so a
  4-element int32 array reads 16 bytes). Bytes land verbatim (no decoding).
• Buffer validation/wrapping lives in one shared helper,
  util.convert.as_writable_c_buffer, so there's no per-backend duplication.
• Each backend's thin read_process_memory_into reuses its existing low-level
  read primitive (ReadProcessMemory / process_vm_readv /
  mach_vm_read_overwrite), including the same partial-read → OSError guard
  the regular read already enforces.

Errors

• TypeError — buffer not writable (e.g. immutable bytes; use bytearray).
• ValueError — buffer empty or not contiguous.
• OSError — read failed or returned fewer bytes than requested.

Tests

New tests/memory/test_read_into.py (11 cases): bytearray / ctypes / memoryview
/ numpy targets, buffer reuse across reads, byte-length sizing, parity with
read_process_memory, and the three error paths.

• Full suite green on macOS: 469 passed, 14 skipped.
• The Windows and Linux backends mirror the macOS path exactly and compile
  cleanly, but were not executed locally — worth confirming via CI on those
  platforms.

Docs

• New "Reusing a buffer (zero-copy reads)" section in docs/guide/read-write.md.
• Method entry added to the API reference (docs/api/openprocess.md).