Add the ability to edit remote directories over SSH (#14530)

This is a first step towards allowing you to edit remote projects
directly over SSH. We'll start with a pretty bare-bones feature set, and
incrementally add further features.

### Todo

Distribution
* [x] Build nightly releases of `zed-remote-server` binaries
    * [x] linux (arm + x86)
    * [x] mac (arm + x86)
* [x] Build stable + preview releases of `zed-remote-server`
* [x] download and cache remote server binaries as needed when opening
ssh project
* [x] ensure server has the latest version of the binary


Auth
* [x] allow specifying password at the command line
* [x] auth via ssh keys
* [x] UI password prompt

Features
* [x] upload remote server binary to server automatically
* [x] opening directories
* [x] tracking file system updates
* [x] opening, editing, saving buffers
* [ ] file operations (rename, delete, create)
* [ ] git diffs
* [ ] project search

Release Notes:

- N/A

---------

Co-authored-by: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>

crates/remote/src/protocol.rs

@@ -0,0 +1,51 @@
+use anyhow::Result;
+use futures::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
+use prost::Message as _;
+use rpc::proto::Envelope;
+use std::mem::size_of;
+
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct MessageId(pub u32);
+
+pub type MessageLen = u32;
+pub const MESSAGE_LEN_SIZE: usize = size_of::<MessageLen>();
+
+pub fn message_len_from_buffer(buffer: &[u8]) -> MessageLen {
+    MessageLen::from_le_bytes(buffer.try_into().unwrap())
+}
+
+pub async fn read_message_with_len<S: AsyncRead + Unpin>(
+    stream: &mut S,
+    buffer: &mut Vec<u8>,
+    message_len: MessageLen,
+) -> Result<Envelope> {
+    buffer.resize(message_len as usize, 0);
+    stream.read_exact(buffer).await?;
+    Ok(Envelope::decode(buffer.as_slice())?)
+}
+
+pub async fn read_message<S: AsyncRead + Unpin>(
+    stream: &mut S,
+    buffer: &mut Vec<u8>,
+) -> Result<Envelope> {
+    buffer.resize(MESSAGE_LEN_SIZE, 0);
+    stream.read_exact(buffer).await?;
+    let len = message_len_from_buffer(buffer);
+    read_message_with_len(stream, buffer, len).await
+}
+
+pub async fn write_message<S: AsyncWrite + Unpin>(
+    stream: &mut S,
+    buffer: &mut Vec<u8>,
+    message: Envelope,
+) -> Result<()> {
+    let message_len = message.encoded_len() as u32;
+    stream
+        .write_all(message_len.to_le_bytes().as_slice())
+        .await?;
+    buffer.clear();
+    buffer.reserve(message_len as usize);
+    message.encode(buffer)?;
+    stream.write_all(buffer).await?;
+    Ok(())
+}