Implement Send for Stream on certain platforms

[bushrat011899]

Objective

• Implement feature in request Implement Send for Stream #818

Solution

Moved NotSendSyncAcrossAllPlatforms into its own module, maybe_send (for clarity) and implemented Send for an instance where (I believe) it is safe to do so. I've deliberately left the cfg statement controlling this implementation verbose to make it clear how other platforms could be included where it is confirmed to be safe to do so:

#[cfg(any(
    // Windows with WASAPI allows for a Send Stream
    all(windows, not(feature = "asio"))
))]
unsafe impl Send for NotSendSyncAcrossAllPlatforms {}

To add this support to Linux but only on FreeBSD using Jack (as an example) then a single statement can be added without modifying any of the others:

#[cfg(any(
    // Windows with WASAPI allows for a Send Stream
    all(windows, not(feature = "asio"))
    // FreeBSD using Jack allows for a Send Stream
    all(target_os = "freebsd", feature = "jack"),
))]
unsafe impl Send for NotSendSyncAcrossAllPlatforms {}

I have deliberately only implemented Send on Windows under WASAPI in this pull request as I believe it is known to be Send safe and should be relatively straight-forward to test. I would encourage others to test on platforms they can also confirm the behaviour on and then make follow-up PRs to increase support.

Motivation

I personally ran into this issue myself when working with Bevy and thought it was a little annoying. Not a deal breaker by any stretch of the imagination, the workarounds are well documented and perfectly reasonable. This is more of a quality of life improvement than anything else.

[bushrat011899]

As a small test, the beep example can be modified like below to demonstrate the send-nature of a Stream (on supported platforms):

pub fn run<T>(device: &cpal::Device, config: &cpal::StreamConfig) -> Result<(), anyhow::Error>
where
    T: SizedSample + FromSample<f32>,
{
    // snip

    // Create the stream on the main thread...
    let stream = device.build_output_stream(
        config,
        move |data: &mut [T], _: &cpal::OutputCallbackInfo| {
            write_data(data, channels, &mut next_value)
        },
        err_fn,
        None,
    )?;

    // ...then send it to a new thread and play it...
    let stream = std::thread::spawn(move || {
        stream.play()?;
    
        std::thread::sleep(std::time::Duration::from_millis(1000));

        Ok::<_, anyhow::Error>(stream)
    });

    // ...get it back and then pause and play it again.
    let stream = stream.join().unwrap()?;

    stream.pause()?;

    std::thread::sleep(std::time::Duration::from_millis(1000));
    
    stream.play()?;

    std::thread::sleep(std::time::Duration::from_millis(1000));

    Ok(())
}