[codec] Replace `Protobuf` with Manual Packing

[patrick-ogrady]

When first implementing the p2p primitive, I decided to use Protobuf and represent PublicKey/Signature with Bytes (which prost could automatically use). However, the migration to Array (#447) makes Protobuf a lot less enjoyable to use (it was already less performant but is also even more so now).

We now need to parse fields from proto and keep them around with the proto object:

• monorepo/consensus/src/lib.rs

  Lines 30 to 38 in ccf2f88

  	/// Parsed is a wrapper around a message that has a parsable digest.
  	#[derive(Clone)]
  	struct Parsed<Message, Digest: Array> {
  	/// Raw message that has some field that can be parsed into a digest.
  	pub message: Message,
  	/// Parsed digest.
  	pub digest: Digest,
  	}

• https://github.com/commonwarexyz/monorepo/blob/b668dfad229fd16797c29f4fb461544f1b4fa72e/broadcast/src/linked/safe/private.rs

We should consider dropping protobuf altogether in primitives for manually packed byte payloads (which can parse generic types directly).

Related: #454

[patrick-ogrady]

This change may pair very well with #434 (we could parse messages + verify signatures concurrently and then pass the formatted messages to the application).

[patrick-ogrady]

A convenient byproduct of this would also be removing this constant:

monorepo/p2p/src/authenticated/network.rs

Line 31 in 0d7677e

const PROTOBUF_OVERHEAD: usize = 64;

[patrick-ogrady]

May make sense to add a Version/Flag type that has 4 bits dedicated to version and 4 bits dedicated to flags (for including/not including different object components).

[patrick-ogrady]

I'm not sure if there is any analysis on "worst case" parsing of adversarial Protobuf payloads of different sizes but that would be very interesting to dig into 👀

[patrick-ogrady]

This should be implemented as a "versioned codec" where we treat "version" as a first-class function of serialization/deserialization:

monorepo/consensus/src/simplex/prover.rs

Lines 54 to 61 in 3724c82

	// Encode proof
	let mut proof = Vec::with_capacity(len);
	proof.put_u64(proposal.view);
	proof.put_u64(proposal.parent);
	proof.extend_from_slice(&proposal.payload);
	proof.extend_from_slice(public_key);
	proof.extend_from_slice(signature);
	proof.into()

This could look like: codec::with_capacity(version, len). We may want to support adding to a pre-existing buffer as well (let's say a sub-encoding in a bigger struct).