Refactor the imp/gui bondary to use real traits (#18)

# Summary

Introduces a trait-based platform abstraction layer that makes the boundary
between platform-specific and shared code explicit and compile-time verified.

The TLDR version of this new trait stuff works:

1. Define a `PlatformInterface` trait.
2. Each platform defines a zero-sized struct implementing the trait (ex `WebPlatform`).
3. Create an ifdef'd type alias on those structs:

```rust
#[cfg(feature = "web")]
pub type Platform = web::WebPlatform;

#[cfg(all(feature = "desktop"))]
pub type Platform = desktop::DesktopPlatform;

#[cfg(all(feature = "mobile", not(feature = "web")))]
pub type Platform = mobile::MobilePlatform;
```

5. Add a compile time assertion that `Platform` implements `PlatformInterface`.

#  Motivation

Previously, platform code used a mix of pub use re-exports and #[cfg] blocks
that made it difficult to understand what each platform must implement. The
new trait-based approach provides:

- Clear documentation of the platform contract
- Compile-time verification that all platforms implement required
  functionality
- Ability to cargo check without feature flags (via stub platform)

# Changes

New traits in imp/mod.rs:
  - PlatformInterface - logging, permissions, network, config, storage. Overall this the trait that platforms must satify to compile.
  - AudioSystemInterface - audio system initialization and recording
  - AudioPlayerInterface - opus audio playback

 Type aliases:
  - Platform, AudioSystem, AudioPlayer resolve to the correct types based on
  feature flags

Call site updates:
  - Changed from imp::function() to Platform::function() syntax
  - Removed ImpRead/ImpWrite helper traits in favor of direct bounds

# Testing

Manual testing reveals that Web and Desktop still work, I (Liam) have not tested the mobile version beyond compilation.

Co-authored-by: Liam Warfield <liam.warfield@gmail.com>
Reviewed-on: #18
Co-authored-by: Sam Sartor <me@samsartor.com>
Co-committed-by: Sam Sartor <me@samsartor.com>

gui/src/imp/stub.rs

@@ -0,0 +1,119 @@
+/// Stub implementation of the platform interface, so that we can
+/// `cargo check` without any --feature flags.
+use crate::effects::AudioProcessor;
+use color_eyre::eyre::Error;
+use dioxus::hooks::UnboundedReceiver;
+use mumble_web2_common::{ClientConfig, ServerStatus};
+use std::future::Future;
+
+pub struct StubPlatform;
+
+impl super::PlatformInterface for StubPlatform {
+    type AudioSystem = StubAudioSystem;
+
+    fn init_logging() {
+        panic!("stubbed platform")
+    }
+
+    fn request_permissions() {
+        panic!("stubbed platform")
+    }
+
+    fn network_connect(
+        _address: String,
+        _username: String,
+        _event_rx: &mut UnboundedReceiver<crate::app::Command>,
+        _gui_config: &ClientConfig,
+    ) -> impl Future<Output = Result<(), Error>> {
+        async { panic!("stubbed platform") }
+    }
+
+    fn get_status(
+        _client: &reqwest::Client,
+    ) -> impl Future<Output = color_eyre::Result<ServerStatus>> {
+        async { panic!("stubbed platform") }
+    }
+
+    fn load_config() -> impl Future<Output = color_eyre::Result<ClientConfig>> {
+        async { panic!("stubbed platform") }
+    }
+
+    fn load_username() -> Option<String> {
+        panic!("stubbed platform")
+    }
+
+    fn load_server_url() -> Option<String> {
+        panic!("stubbed platform")
+    }
+
+    fn set_default_username(_username: &str) -> Option<()> {
+        panic!("stubbed platform")
+    }
+
+    fn set_default_server(_server: &str) -> Option<()> {
+        panic!("stubbed platform")
+    }
+
+    fn sleep(_duration: std::time::Duration) -> impl Future<Output = ()> {
+        async { panic!("stubbed platform") }
+    }
+}
+
+pub struct StubAudioSystem;
+
+impl super::AudioSystemInterface for StubAudioSystem {
+    type AudioPlayer = StubAudioPlayer;
+
+    async fn new() -> Result<Self, Error> {
+        panic!("stubbed platform")
+    }
+
+    fn set_processor(&self, _processor: AudioProcessor) {
+        panic!("stubbed platform")
+    }
+
+    fn start_recording(
+        &mut self,
+        _each: impl FnMut(Vec<u8>, bool) + Send + 'static,
+    ) -> Result<(), Error> {
+        panic!("stubbed platform")
+    }
+
+    fn create_player(&mut self) -> Result<Self::AudioPlayer, Error> {
+        panic!("stubbed platform")
+    }
+}
+
+pub struct StubAudioPlayer;
+
+impl super::AudioPlayerInterface for StubAudioPlayer {
+    fn play_opus(&mut self, _payload: &[u8]) {
+        panic!("stubbed platform")
+    }
+}
+
+#[allow(unused)]
+pub struct SpawnHandle;
+
+impl SpawnHandle {
+    #[allow(unused)]
+    pub fn spawn<F>(&self, _future: F)
+    where
+        F: Future<Output = ()> + 'static,
+    {
+        panic!("stubbed platform")
+    }
+
+    #[allow(unused)]
+    pub fn current() -> Self {
+        SpawnHandle
+    }
+}
+
+#[allow(unused)]
+pub fn spawn<F>(_future: F)
+where
+    F: Future<Output = ()> + 'static,
+{
+    panic!("stubbed platform")
+}