Establishes the V2 serialization API as the new internal foundation for
Akka.NET's serialization subsystem. V1 serializers continue to work
unchanged via a transparent adapter.

New types in core Akka:

- SerializerV2 (abstract): Buffer-aware serializer base class with
  Serialize(IBufferWriter<byte>, object), Deserialize(ReadOnlySequence<byte>,
  string), Manifest(object), and Identifier. Virtual byte[] bridges
  (ToBinary/FromBinary) keep V1-style call sites working.
- SerializerV1Adapter: Wraps Serializer/SerializerWithStringManifest as a
  SerializerV2. Reproduces the V1 manifest dispatch (TypeQualifiedName for
  IncludeManifest=true plain serializers, custom manifest for
  SerializerWithStringManifest, empty otherwise) and delegates ToBinary/
  FromBinary/FromBinary(Type) directly to the inner V1 to avoid pointless
  buffer round trips. Inner property exposes the wrapped V1 instance.
- SerializerV2Extensions: AsV1<T>()/TryAsV1<T>() helpers for callers that
  hold strongly-typed references to V1 serializers (e.g. cast sites in
  tests and durable stores).

Serialization.cs changes:

- Internal storage migrated to SerializerV2 (auto-wraps V1 on registration
  from HOCON, SerializationSetup, AddSerializer, AddSerializationMap)
- FindSerializerFor / FindSerializerForType / GetSerializerById /
  GetSerializerByName return SerializerV2
- ManifestFor(SerializerV2, object) overload added (just delegates to
  Manifest()); legacy ManifestFor(Serializer, object) preserved for back
  compat
- AddSerializer / AddSerializationMap each have V1 + V2 overloads (V1
  auto-wraps)
- Deserialize(byte[], int, string) simplified to uniform V2 dispatch —
  the V1 adapter handles the type-vs-manifest dance internally

Akka.Remote.MessageSerializer.cs:

- Single uniform path for manifest dispatch via SerializerV2.Manifest();
  no more `is SerializerWithStringManifest` type check or `IncludeManifest`
  branch

Call site fixes (mechanical):

- ~25 cast sites in tests/benchmarks switched to .AsV1<T>() (covers
  Hyperion, Newtonsoft, Cluster, Sharding, ClusterClient, PubSub,
  Singleton, ReplicatedDataSerializer, custom test serializers, and
  Akka.Remote.Tests primitive/misc)
- Field declarations on Replicator._serializer and
  LocalSnapshotStore._wrapperSerializer changed to SerializerV2
- ActorSystemImpl.WarnIfJsonIsDefaultSerializer uses
  SerializerV1Adapter pattern match
- Akka.Persistence.Custom example simplified to use uniform V2
  Manifest() dispatch
- ClusterMessageSerializer.GetObjectManifest takes SerializerV2

Adapter overrides bridge methods (ToBinary, FromBinary(byte[],string),
FromBinary(byte[],Type)) to delegate to the inner V1 directly. V2-native
Deserialize materializes the ReadOnlySequence<byte> to byte[] before
calling FromBinary, since the wrapped V1 is byte[]-native — no
performance win is possible for V1, only API parity. V2-native
serializers (coming next: ByteArraySerializer + PrimitiveSerializers
ports) get the actual zero-copy benefit.

Build: 0 errors, 0 warnings on full solution.

Existing tests asserted on the V1 serializer type via
.Should().BeOfType<T>() or by direct cast. With V2 dispatch wrapping V1
serializers in SerializerV1Adapter, those assertions now see the adapter
type and fail.

Mechanical fix across the affected test files: replace
.Should().BeOfType<V1>() with .AsV1<V1>() (which throws if the V2
instance isn't a SerializerV1Adapter wrapping V1). The implicit
assertion has the same intent — verify the right V1 serializer is bound
— without requiring the test to know about the adapter wrapping.

Affected test files:
- Akka.Tests: SerializationSpec, SerializationSetupSpec, CustomSerializerSpec
- Akka.Remote.Tests: DaemonMsgCreateSerializerSpec, MessageContainerSerializerSpec, MiscMessageSerializerSpec, ProtobufSerializerSpec, SystemMessageSerializationSpec
- Akka.Cluster.Tests: ReliableDeliverySerializerSpecs
- Akka.Cluster.Tools.Tests: ClusterClientSerializerSpec
- Akka.DistributedData.Tests: ReplicatedDataSerializerSpec
- Akka.Cluster.Sharding.Tests: DDataClusterShardingConfigSpec

`using Akka.Serialization;` added where missing to bring the AsV1 /
TryAsV1 extensions into scope.

Test status:
- Akka.Tests: 1248 passing, 23 skipped, 0 failing (full suite)
- Akka.Remote.Tests serialization: 105 passing, 1 skipped, 0 failing
- Akka.Cluster.Tests serialization: 49 passing, 0 failing
- Akka.Cluster.Tools.Tests serialization: 51 passing, 0 failing

Both serializers now extend SerializerV2 directly instead of the legacy
Serializer base class, while preserving their serializer IDs (4 and 17
respectively) and producing byte-identical wire format. They are the
V2-native reference implementations used to validate the API.

ByteArraySerializer (Akka core, ID 4):

- Identity transform — the byte[] is the wire format
- Serialize(IBufferWriter<byte>, byte[]) copies the input into the writer
  (the writer contract requires it; the V2 path costs one copy)
- Deserialize(ReadOnlySequence<byte>, manifest) materializes a fresh
  byte[] via seq.ToArray() — callers may retain the returned reference,
  so we cannot alias to potentially pooled backing memory
- ToBinary/FromBinary bridges overridden to skip the buffer round trip
  and pass the byte[] through directly (V1's zero-alloc behavior is
  preserved for the bridge path)
- Manifest() returns string.Empty (no manifest needed)
- Null handling drops V1's null passthrough — Serialization.cs routes
  null through NullSerializer, so the path was unreachable

PrimitiveSerializers (Akka.Remote, ID 17):

- Covers string / int32 / int64 with the same six manifest aliases as V1
  (S/I/L plus the long-form .NET Core and .NET Framework type-name
  variants that legacy peers emit)
- String serialize: Encoding.UTF8.GetBytes(string, Span<byte>) into the
  writer's span — no intermediate byte[] allocation
- Int32/Int64 serialize: BinaryPrimitives.WriteInt*LittleEndian into
  fixed-width spans
- String deserialize: Encoding.UTF8.GetString(ReadOnlySequence<byte>) on
  net6+, handles split codepoints across multi-segment input
- Int32/Int64 deserialize: BinaryPrimitives.ReadInt*LittleEndian; falls
  back to a stack copy when the value spans a segment boundary
- ToBinary/FromBinary bridges overridden — strings use
  Encoding.UTF8.GetBytes(string), ints use BitConverter on
  little-endian platforms (matching V1 byte-for-byte) and a manual
  little-endian fallback otherwise
- use-legacy-behavior config flag preserved
- SizeHint(o) returns precise sizes for fixed-width values and
  GetMaxByteCount(string.Length) for strings — gives the
  ArrayBufferWriter inside the bridge a tight initial allocation

Test fixes:

- SerializationSpec.cs / SerializationSpec.AllowUnregisteredTypesSpec:
  ByteArraySerializer is V2-native now, so the previous
  AsV1<ByteArraySerializer>() pattern is invalid (the type constraint
  T : Serializer rejects V2 types). Replaced with direct
  Should().BeOfType<ByteArraySerializer>() on the result.
- PrimitiveSerializersSpec.cs: same — switched from .AsV1<PrimitiveSerializers>()
  to .Should().BeOfType<PrimitiveSerializers>().Subject (FluentAssertions
  pattern that returns the typed subject).

Test status:
- Akka.Tests serialization: 65 passing, 0 failing
- Akka.Remote.Tests PrimitiveSerializersSpec: 17 passing, 0 failing

Direct unit tests for SerializerV1Adapter that exercise the wrapping
behavior independently of Serialization's registration plumbing.
Full HOCON / V1 auto-wrap path coverage continues to live in
SerializationSpec and CustomSerializerSpec — this spec is for the
adapter's own contract.

Coverage:
- Round-trip through buffer API (Serialize/Deserialize) for plain V1
  with and without IncludeManifest, and for SerializerWithStringManifest
- Round-trip through byte[] bridge (ToBinary/FromBinary) for both
  string-manifest and Type-typed FromBinary overloads
- Manifest behavior matches V1 dispatch (TypeQualifiedName for
  IncludeManifest=true plain serializers, custom string for
  SerializerWithStringManifest, empty for IncludeManifest=false)
- Identifier preserved from inner V1
- Inner property returns the wrapped instance unchanged
- ToBinary/FromBinary bridge overrides produce byte-identical output to
  the inner V1 (so the bridge skip is correct)
- Multi-segment ReadOnlySequence<byte> input handled correctly
- AsV1<T>/TryAsV1<T> extension methods unwrap correctly and have the
  expected null-vs-throw failure semantics

Three V1 fixture classes cover the three V1 dispatch flavors; a small
ReadOnlySequenceSegment<byte> helper synthesizes multi-segment input
without depending on a Pipe.

15/15 tests pass.

Benchmark (src/benchmark/Akka.Benchmarks/Serialization/SerializerV2EnvelopeBenchmarks.cs):

Simulates what EndpointWriter will do once Spec 3 wires the Streams TCP
transport to call SerializerV2.Serialize(IBufferWriter<byte>) directly:
writes a Remote-shaped envelope to an ArrayBufferWriter<byte>, wraps the
result as a ReadOnlySequence<byte>, reads the header via
SequenceReader<byte>, hands the payload slice to
SerializerV2.Deserialize(ReadOnlySequence<byte>, manifest). Compares
against the V1-bridge path (ToBinary → byte[] → FromBinary) on the same
serializer instance and the same payload.

Envelope shape: [serializerId: int32 LE][manifestLen: int32 LE]
[manifest: utf8][payload: bytes-to-end]. Payload length is implicit —
the outer frame boundary is the boundary, matching how the real Streams
TCP transport will frame messages in Spec 3.

Payload matrix exercises every V2-native primitive path:
- string short (5 chars), medium (256), long (4 KB)
- int32, int64
- byte[] small (16 B), medium (1 KB), large (16 KB)

No Akka.Remote / DotNetty / socket dependencies — pure shape benchmark
to validate the V2 buffer API earns its keep on allocations and
throughput before downstream specs build on it. Reusable for Spec 3
integration: drop in a real FrameBufferWriter in place of
ArrayBufferWriter and re-run to confirm no regression.

Configured with MicroBenchmarkConfig (MemoryDiagnoser + GitHub markdown
exporter); run via the standard BenchmarkDotNet console runner.

API baselines (src/core/Akka.API.Tests/verify/):

- CoreAPISpec.ApproveCore.DotNet.verified.txt: ByteArraySerializer now
  extends SerializerV2; Serialization gets AddSerializer/AddSerializationMap
  V2 overloads, FindSerializerFor[Type] return SerializerV2, ManifestFor
  V2 overload; new public types SerializerV2, SerializerV1Adapter,
  SerializerV2Extensions.
- CoreAPISpec.ApproveRemote.DotNet.verified.txt: PrimitiveSerializers
  now extends SerializerV2 with the buffer Serialize/Deserialize methods.

Test status: 18/18 Akka.API.Tests passing; 0 errors / 0 warnings on full
solution build.

Validates the SerializerV2 design against today's Akka.Remote
MessageSerializer + AkkaPduCodec wrap pipeline. Reuses the existing
Protobuf message types (AckAndEnvelopeContainer / RemoteEnvelope /
Payload) without modification — the V2 path produces byte-equivalent
wire output that Google.Protobuf parses transparently.

What the spike contains

- PatchingBufferWriter: IBufferWriter<byte> with a PatchSpan(offset, len)
  accessor for in-place length-prefix patching.
- ProtoWire: hand-rolled Protobuf wire-format primitives (tag, varint,
  fixed-width varint placeholder + patch, fixed64, string). Mirrors what
  CodedOutputStream does internally, but writes against IBufferWriter
  directly (Google.Protobuf's WriteContext.Initialize(IBufferWriter) is
  internal and not callable from user code).
- V2SerializerRegistry: Type -> SerializerV2 / ID -> SerializerV2
  lookup. Static dispatch, no reflection at serialize time, no
  Type.GetType from manifest strings at deserialize time.
- V2RemoteEnvelopeWriter: writes the full AckAndEnvelopeContainer
  pipeline directly into a PatchingBufferWriter. For each nested
  length-delimited field (envelope, payload, message bytes), reserves a
  fixed-width 5-byte varint placeholder, runs the inner write (using the
  bytes-written int return on SerializerV2.Serialize to know exactly how
  much was written), then patches the length prefix in place.

How the patching technique works around Protobuf's nested-message
length-prefix problem

Protobuf's length-delimited wire format requires the inner's byte
count to be known BEFORE the length prefix is written. Canonical
varints are minimum-width, so a placeholder can't be patched
retroactively without knowing how wide the varint will be.

The trick: write the length prefix as a FIXED-WIDTH 5-byte varint
always. 5 bytes give 35 bits of data — plenty for any uint32. Small
values are encoded as over-long varints (continuation bits set on the
first 4 bytes, value's low bits in byte 0, zeros in the rest).
Google.Protobuf's CodedInputStream accepts up to 5 bytes for a uint32
varint and OR's the data bits regardless of canonicity, so the
over-long form parses to the same value as the minimum-width form.

That lets us reserve 5 bytes, run the inner write, then patch the
varint in place using the int returned by Serialize. One pass, no
scratch buffer, no intermediate byte[].

Wire-overhead cost: at most 4 extra bytes per length-delimited nested
field. For Akka.Remote's three nesting levels, that's max 12 bytes per
message — noise vs payload size.

Wire compat is verified at benchmark setup: V2 output is parsed via
AckAndEnvelopeContainer.Parser.ParseFrom and compared field-by-field
against the V1 output (recipient path, payload bytes, serializer ID).
Throws at setup if anything diverges.

Benchmark results (V1 = real MessageSerializer + AkkaPduProtobuffCodec,
V2 = the spike, both producing wire-equivalent AckAndEnvelopeContainer
bytes):

| Payload      | V1 time   | V2 time   | Ratio | V1 alloc | V2 alloc | Alloc |
|--------------|-----------|-----------|-------|----------|----------|-------|
| StringShort  |  3,522 ns |  2,375 ns | 0.68x |  1,512 B |    840 B | 0.56x |
| StringMedium |  5,092 ns |  4,007 ns | 0.79x |  2,776 B |  1,600 B | 0.58x |
| StringLong   | 14,142 ns | 11,991 ns | 0.87x | 21,976 B | 13,120 B | 0.60x |
| BytesSmall   |  1,665 ns |    482 ns | 0.30x |    688 B |      0 B | 0.00x |
| BytesLarge   | 10,806 ns |  1,001 ns | 0.13x | 33,432 B |      0 B | 0.00x |

byte[] payloads (the canonical wrapped-payload pattern when the inner
is a binary blob) show the dramatic win: 3.5-8x faster and ZERO
managed allocations. string payloads show smaller but real
improvements (15-32% faster, 40-44% fewer allocations) with some
residual allocation I haven't profiled yet (probably warmup/buffer
growth artifacts in BDN's measurement; not blocking the design
validation).

The spike is benchmark-project-only — does not touch the running
Akka.Remote infrastructure. Akka.Benchmarks already has
InternalsVisibleTo from Akka.Remote so the spike can invoke real
MessageSerializer.Serialize and AkkaPduProtobuffCodec.ConstructMessage
directly for the V1 baseline.

Files:
- src/benchmark/Akka.Benchmarks/Serialization/V2ProtoSpike.cs
- src/benchmark/Akka.Benchmarks/Serialization/V2ProtoBenchmarks.cs

Extends the V2 wrap-pipeline spike with a hand-rolled receive-side
parser that mirrors AkkaPduProtobuffCodec.DecodeMessage +
MessageSerializer.Deserialize, but without constructing any of the
intermediate Protobuf message objects.

New types

- ProtoWire read helpers: ReadVarint32, ReadTag, ReadFixed64,
  ReadLengthDelimited, ReadString, SkipField. All take
  `ref ReadOnlySpan<byte>` and advance the span past consumed bytes.
  Accept both canonical and over-long varints, so V2 can parse V1's
  wire output as well as its own.
- V2DeserializedEnvelope: result struct (RecipientPath, SenderPath,
  Seq, Payload). Mirrors what V1's AkkaPduCodec.DecodeMessage produces
  but without the IActorRef resolution step (deferred to the dispatcher).
- V2RemoteEnvelopeReader: parses AckAndEnvelopeContainer wire bytes
  directly into the result struct. Has two entry points:
    Read(ReadOnlySpan<byte>)    - for cases without a Memory backing
    Read(ReadOnlyMemory<byte>)  - zero-copy slicing for the inner-payload bytes
  The Memory overload slices the original buffer at the inner-payload
  offset and wraps as a ReadOnlySequence<byte> for the V2 inner
  serializer's Deserialize. No intermediate byte[] for the inner
  payload — V1 allocates two (the ByteString backing plus ToByteArray).

Dispatch is by integer serializer ID (registry.GetById), not by
Type.GetType(manifest) — no reflection on receive side, no
BinaryFormatter-class attack surface.

Benchmark additions

V2ProtoBenchmarks now runs both directions for every payload kind:

- V1 read: AckAndEnvelopeContainer.Parser.ParseFrom + extract proto
  fields + MessageSerializer.Deserialize (the real Akka.Remote receive
  path)
- V2 read: V2RemoteEnvelopeReader.Read using the Memory overload

Setup verifies cross-version compat: the V2 reader correctly parses
V1's canonical-varint wire bytes. Round-trip equality is asserted for
both string and byte[] payloads (byte[] via SequenceEqual, since
default object Equals on byte[] is reference equality).

Results (V1 = real Akka.Remote path, V2 = spike)

Writes:
  StringShort:  3849ns -> 2374ns (0.62x), 1512 B -> 840 B   (0.56x)
  StringMedium: 4855ns -> 3690ns (0.76x), 2776 B -> 1600 B  (0.58x)
  StringLong:  14058ns -> 11182ns (0.81x), 21976 B -> 13120 B (0.60x)
  BytesSmall:   1519ns -> 487ns  (0.32x), 688 B   -> 0 B    (0.00x)
  BytesLarge:   9204ns -> 1087ns (0.16x), 33432 B -> 0 B    (0.00x)

Reads:
  StringShort:  3418ns -> 2688ns (0.79x), 3416 B  -> 2976 B (0.87x)
  StringMedium: 9801ns -> 7787ns (0.79x), 4936 B  -> 4240 B (0.86x)
  StringLong:  18267ns -> 16190ns (0.89x), 56720 B -> 52184 B (0.92x)
  BytesSmall:   1284ns -> 1275ns (0.99x), 664 B   -> 216 B  (0.33x)
  BytesLarge:   9092ns -> 7051ns (0.78x), 33400 B -> 16584 B (0.50x)

Headlines

- byte[] writes: 3-8x faster, ZERO managed allocations
- byte[] reads: ~22% faster, 50-67% fewer allocations
- string writes: 24-38% faster, 40-44% fewer allocations
- string reads: 11-21% faster, modest allocation reduction (the
  result-string allocation dominates regardless of pipeline)

Both directions show real Akka.Remote-equivalent benefits. The
wrapped-payload pattern is essentially free in V2 for byte[] payloads.