websocket example and helpers to create custom subscriptions

[hecrj]

This PR introduces a couple of helper functions in iced_native::subscription to help users create custom subscriptions.

Specifically, it introduces both a run and unfold method:

/// Returns a [`Subscription`] that will create and asynchronously run the
/// given [`Stream`].
///
/// The `id` will be used to uniquely identify the [`Subscription`].
pub fn run<I, S, Message>(id: I, stream: S) -> Subscription<Message>
where
    I: Hash + 'static,
    S: Stream<Item = Message> + Send + 'static,
    Message: 'static,
{
    // ...
}

/// Returns a [`Subscription`] that will create and asynchronously run a
/// [`Stream`] that will call the provided closure to produce every `Message`.
///
/// The `id` state will be used to uniquely identify the [`Subscription`].
pub fn unfold<I, T, Fut, Message>(
    id: I,
    initial: T,
    mut f: impl FnMut(T) -> Fut + Send + Sync + 'static,
) -> Subscription<Message>
where
    I: Hash + 'static,
    T: Send + 'static,
    Fut: Future<Output = (Option<Message>, T)> + Send + 'static,
    Message: 'static + Send,
{
    // ...
}

The unfold helper can be leveraged to create a Subscription that spawns an asynchronous worker in the background and establish a channel of communication with an iced application.

This can be achieved by creating an mpsc channel inside the closure and returning the Sender as a Message for the Application:

use iced_native::subscription::{self, Subscription};
use iced_native::futures::channel::mpsc;

pub enum Event {
    Ready(mpsc::Sender<Input>),
    WorkFinished,
    // ...
}

enum Input {
    DoSomeWork,
    // ...
}

enum State {
    Starting,
    Ready(mpsc::Receiver<Input>),
}

fn some_worker() -> Subscription<Event> {
    struct SomeWorker;

    subscription::unfold(std::any::TypeId::of::<SomeWorker>(), State::Starting, |state| async move {
        match state {
            State::Starting => {
                // Create channel
                let (sender, receiver) = mpsc::channel(100);

                (Some(Event::Ready(sender)), State::Ready(receiver))
            }
            State::Ready(mut receiver) => {
                use iced_native::futures::StreamExt;

                // Read next input sent from `Application`
                let input = receiver.select_next_some().await;

                match input {
                    Input::DoSomeWork => {
                        // Do some async work...

                        // Finally, we can optionally return a message to tell the
                        // `Application` the work is done
                        (Some(Event::WorkFinished), State::Ready(receiver))
                    }
                }
            }
        }
    })
}

As usual, I have implemented a new example to showcase this functionality. The new websocket example uses the subscription::unfold helper to open and maintain a WebSocket connection to an echo server. The Application can send and receive messages from the WebSocket managed by the Subscription.

I hope this makes implementing custom subscriptions considerably easier for everyone!

Closes #1172.
Closes #405.