⭐ feat: Migrate from WebSocket to libp2p for peer-to-peer connectivity (#286)

## Description
Whew, some stuff is still not re-implemented, but it's working!

Rabbit's gonna explode with the amount of changes I reckon 😅



<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- **New Features**
- Introduced a peer-to-peer relay system using libp2p with enhanced
stream forwarding, room state synchronization, and mDNS peer discovery.
- Added decentralized room and participant management, metrics
publishing, and safe, size-limited, concurrent message streaming with
robust framing and callback dispatching.
- Implemented asynchronous, callback-driven message handling over custom
libp2p streams replacing WebSocket signaling.
- **Improvements**
- Migrated signaling and stream protocols from WebSocket to libp2p,
improving reliability and scalability.
- Simplified configuration and environment variables, removing
deprecated flags and adding persistent data support.
- Enhanced logging, error handling, and connection management for better
observability and robustness.
- Refined RTP header extension registration and NAT IP handling for
improved WebRTC performance.
- **Bug Fixes**
- Improved ICE candidate buffering and SDP negotiation in WebRTC
connections.
  - Fixed NAT IP and UDP port range configuration issues.
- **Refactor**
- Modularized codebase, reorganized relay and server logic, and removed
deprecated WebSocket-based components.
- Streamlined message structures, removed obsolete enums and message
types, and simplified SafeMap concurrency.
- Replaced WebSocket signaling with libp2p stream protocols in server
and relay components.
- **Chores**
- Updated and cleaned dependencies across Go, Rust, and JavaScript
packages.
  - Added `.gitignore` for persistent data directory in relay package.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: DatCaptainHorse <DatCaptainHorse@users.noreply.github.com>
Co-authored-by: Philipp Neumann <3daquawolf@gmail.com>

packages/server/src/messages.rs

@@ -1,8 +1,5 @@
 use crate::latency::LatencyTracker;
-use num_derive::{FromPrimitive, ToPrimitive};
-use num_traits::{FromPrimitive, ToPrimitive};
 use serde::{Deserialize, Serialize};
-use std::error::Error;
 use webrtc::ice_transport::ice_candidate::RTCIceCandidateInit;
 use webrtc::peer_connection::sdp::session_description::RTCSessionDescription;
 
@@ -12,6 +9,13 @@ pub struct MessageBase {
     pub latency: Option<LatencyTracker>,
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+pub struct MessageRaw {
+    #[serde(flatten)]
+    pub base: MessageBase,
+    pub data: serde_json::Value,
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 pub struct MessageLog {
     #[serde(flatten)]
@@ -44,76 +48,3 @@ pub struct MessageSDP {
     pub base: MessageBase,
     pub sdp: RTCSessionDescription,
 }
-
-#[repr(i32)]
-#[derive(Debug, FromPrimitive, ToPrimitive, Copy, Clone, Serialize, Deserialize)]
-#[serde(try_from = "i32", into = "i32")]
-pub enum JoinerType {
-    JoinerNode = 0,
-    JoinerClient = 1,
-}
-impl TryFrom<i32> for JoinerType {
-    type Error = &'static str;
-
-    fn try_from(value: i32) -> Result<Self, Self::Error> {
-        JoinerType::from_i32(value).ok_or("Invalid value for JoinerType")
-    }
-}
-impl From<JoinerType> for i32 {
-    fn from(joiner_type: JoinerType) -> Self {
-        joiner_type.to_i32().unwrap()
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct MessageJoin {
-    #[serde(flatten)]
-    pub base: MessageBase,
-    pub joiner_type: JoinerType,
-}
-
-#[repr(i32)]
-#[derive(Debug, FromPrimitive, ToPrimitive, Copy, Clone, Serialize, Deserialize)]
-#[serde(try_from = "i32", into = "i32")]
-pub enum AnswerType {
-    AnswerOffline = 0,
-    AnswerInUse = 1,
-    AnswerOK = 2,
-}
-impl TryFrom<i32> for AnswerType {
-    type Error = &'static str;
-
-    fn try_from(value: i32) -> Result<Self, Self::Error> {
-        AnswerType::from_i32(value).ok_or("Invalid value for AnswerType")
-    }
-}
-impl From<AnswerType> for i32 {
-    fn from(answer_type: AnswerType) -> Self {
-        answer_type.to_i32().unwrap()
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct MessageAnswer {
-    #[serde(flatten)]
-    pub base: MessageBase,
-    pub answer_type: AnswerType,
-}
-
-pub fn encode_message<T: Serialize>(message: &T) -> Result<String, Box<dyn Error>> {
-    // Serialize the message to JSON
-    let json = serde_json::to_string(message)?;
-    Ok(json)
-}
-
-pub fn decode_message(data: String) -> Result<MessageBase, Box<dyn Error + Send + Sync>> {
-    let base_message: MessageBase = serde_json::from_str(&data)?;
-    Ok(base_message)
-}
-
-pub fn decode_message_as<T: for<'de> Deserialize<'de>>(
-    data: String,
-) -> Result<T, Box<dyn Error + Send + Sync>> {
-    let message: T = serde_json::from_str(&data)?;
-    Ok(message)
-}