feat(notify): 重构通信内核并补齐 stream/bulk/record/transfer 能力

- 引入 LogicalConn/TransportConn 分层，ClientConn 保留兼容适配层
  - 新增 Stream、Bulk、RecordStream 三条数据面能力及对应控制路径
  - 完成 transfer/file 传输内核与状态快照、诊断能力
  - 补齐 reconnect、inbound dispatcher、modern psk 等基础模块
  - 增加大规模回归、并发与基准测试覆盖
  - 更新依赖库

stream_fastpath.go

@@ -0,0 +1,127 @@
+package notify
+
+import (
+	"encoding/binary"
+	"errors"
+)
+
+var (
+	errStreamFastPayloadInvalid = errors.New("invalid stream fast payload")
+	errStreamFastDataIDEmpty    = errors.New("stream data id is empty")
+)
+
+const (
+	streamFastPayloadMagic     = "NSF1"
+	streamFastPayloadVersion   = 1
+	streamFastPayloadTypeData  = 1
+	streamFastPayloadHeaderLen = 28
+)
+
+type streamFastDataFrame struct {
+	Flags   uint8
+	DataID  uint64
+	Seq     uint64
+	Payload []byte
+}
+
+func encodeStreamFastDataFrameHeader(dst []byte, dataID uint64, seq uint64, payloadLen int) error {
+	if dataID == 0 {
+		return errStreamFastDataIDEmpty
+	}
+	if len(dst) < streamFastPayloadHeaderLen {
+		return errStreamFastPayloadInvalid
+	}
+	copy(dst[:4], streamFastPayloadMagic)
+	dst[4] = streamFastPayloadVersion
+	dst[5] = streamFastPayloadTypeData
+	dst[6] = 0
+	dst[7] = 0
+	binary.BigEndian.PutUint64(dst[8:16], dataID)
+	binary.BigEndian.PutUint64(dst[16:24], seq)
+	binary.BigEndian.PutUint32(dst[24:28], uint32(payloadLen))
+	return nil
+}
+
+func encodeStreamFastDataFrame(dataID uint64, seq uint64, payload []byte) ([]byte, error) {
+	frame := make([]byte, streamFastPayloadHeaderLen+len(payload))
+	if err := encodeStreamFastDataFrameHeader(frame, dataID, seq, len(payload)); err != nil {
+		return nil, err
+	}
+	copy(frame[streamFastPayloadHeaderLen:], payload)
+	return frame, nil
+}
+
+func decodeStreamFastDataFrame(payload []byte) (streamFastDataFrame, bool, error) {
+	if len(payload) < 4 || string(payload[:4]) != streamFastPayloadMagic {
+		return streamFastDataFrame{}, false, nil
+	}
+	if len(payload) < streamFastPayloadHeaderLen {
+		return streamFastDataFrame{}, true, errStreamFastPayloadInvalid
+	}
+	if payload[4] != streamFastPayloadVersion || payload[5] != streamFastPayloadTypeData {
+		return streamFastDataFrame{}, true, errStreamFastPayloadInvalid
+	}
+	dataLen := int(binary.BigEndian.Uint32(payload[24:28]))
+	if dataLen < 0 || len(payload) != streamFastPayloadHeaderLen+dataLen {
+		return streamFastDataFrame{}, true, errStreamFastPayloadInvalid
+	}
+	dataID := binary.BigEndian.Uint64(payload[8:16])
+	if dataID == 0 {
+		return streamFastDataFrame{}, true, errStreamFastPayloadInvalid
+	}
+	return streamFastDataFrame{
+		Flags:   payload[6],
+		DataID:  dataID,
+		Seq:     binary.BigEndian.Uint64(payload[16:24]),
+		Payload: payload[streamFastPayloadHeaderLen:],
+	}, true, nil
+}
+
+func (c *ClientCommon) encodeFastStreamDataPayload(dataID uint64, seq uint64, chunk []byte) ([]byte, error) {
+	if c != nil && c.fastStreamEncode != nil {
+		return c.fastStreamEncode(c.SecretKey, dataID, seq, chunk)
+	}
+	plain, err := encodeStreamFastDataFrame(dataID, seq, chunk)
+	if err != nil {
+		return nil, err
+	}
+	return c.encryptTransportPayload(plain)
+}
+
+func (c *ClientCommon) sendFastStreamData(dataID uint64, seq uint64, chunk []byte) error {
+	payload, err := c.encodeFastStreamDataPayload(dataID, seq, chunk)
+	if err != nil {
+		return err
+	}
+	return c.writePayloadToTransport(payload)
+}
+
+func (s *ServerCommon) encodeFastStreamDataPayloadLogical(logical *LogicalConn, dataID uint64, seq uint64, chunk []byte) ([]byte, error) {
+	if logical != nil {
+		if fastStreamEncode := logical.fastStreamEncodeSnapshot(); fastStreamEncode != nil {
+			return fastStreamEncode(logical.secretKeySnapshot(), dataID, seq, chunk)
+		}
+	}
+	plain, err := encodeStreamFastDataFrame(dataID, seq, chunk)
+	if err != nil {
+		return nil, err
+	}
+	return s.encryptTransportPayloadLogical(logical, plain)
+}
+
+func (s *ServerCommon) sendFastStreamDataTransport(logical *LogicalConn, transport *TransportConn, dataID uint64, seq uint64, chunk []byte) error {
+	if err := s.ensureServerTransportSendReady(transport); err != nil {
+		return err
+	}
+	if logical == nil && transport != nil {
+		logical = transport.logicalConnSnapshot()
+	}
+	if logical == nil {
+		return errTransportDetached
+	}
+	payload, err := s.encodeFastStreamDataPayloadLogical(logical, dataID, seq, chunk)
+	if err != nil {
+		return err
+	}
+	return s.writeEnvelopePayload(logical, transport, nil, payload)
+}