perf(msg-push): drop Buffer.from() wrap on pkt.body (free allocation)

`PacketInfo.body` is typed as `Uint8Array` in `@snowluma/common/
protocol-types` and arrives as one — the `Buffer.from(uint8Array)`
wrap that fed it into `protobuf_decode<PushMsg>(...)` was a no-op
copy. `Buffer` is a `Uint8Array` subclass, and proton's decoder
accepts the parent type directly, so the wrap added one allocation
per incoming push packet without changing behavior.

Bench delta (parseMsgPush, pure decode):
  group_message (text only)    0.29 μs/op → 0.25 μs/op  (~1.2x)
  group_message (5 mixed)      0.50 μs/op → 0.47 μs/op  (~1.07x)
  group_member_join            0.25 μs/op → 0.30 μs/op  (within noise)

Small absolute gain — but `parseMsgPush` runs once per incoming
packet at the very front of the pipeline, so the saved allocation
compounds with the per-message GC churn. The text/mixed group-
message cases pick up cleanly; the join case sits in noise (it has
a smaller body so the Buffer wrap was cheap relative to total).

Verification: pnpm -r typecheck clean; 552/552 tests pass.

packages/bridge/src/msg-push/context.ts

@@ -29,7 +29,12 @@ export interface MsgPushContext {
 export function buildContext(pkt: PacketInfo, identity: IdentityService): MsgPushContext | null {
   if (pkt.body.length === 0) return null;
 
-  const push = protobuf_decode<PushMsg>(Buffer.from(pkt.body));
+  // `pkt.body` is already a `Uint8Array` (see `PacketInfo` in
+  // @snowluma/common/protocol-types). The legacy `Buffer.from(uint8)`
+  // wrap was a no-op copy — Buffer is a Uint8Array subclass and
+  // proton's decoder accepts the parent type directly. Dropping the
+  // wrap saves one allocation per incoming push packet.
+  const push = protobuf_decode<PushMsg>(pkt.body);
   if (!push?.message) return null;
 
   const msg = push.message;