API to check whether we are inside a simulation

[teskje]

This adds turmoil::in_simulation, an API that allows checking whether the caller is currently running inside a simulation.

The same information was already obtainable by turmoil::sim_elapsed().is_some(), but it seems good to have a less obscure way to do this.

---

For context, my reason for wanting this is that I have a TcpStream wrapper that supports both tokio and turmoil streams and decides which type to use at runtime. Roughly:

enum TcpStream {
    Tokio(tokio::net::TcpStream),
    Turmoil(turmoil::net::TcpStream),
}

impl TcpStream {
    async fn connect<A: ToSocketAddrs>(addr: A) -> io::Result<Self> {
        if turmoil::in_simulation() {
            turmoil::net::TcpStream::connect(addr).await.map(Self::Turmoil)
        } else {
            tokio::net::TcpStream::connect(addr).await.map(Self::Tokio)
        }
    }
}

This is for situations where I can't decide this at compile time, for example because I'm using turmoil in Rust tests and there are other tests in the same binary that want to use the tokio types instead.

Happy to discuss other ways of doing this, if folks have ideas!

[mcches]

A couple alternatives...but the proposed is also Ok.

Option 1: Use try_current

pub fn in_simulation() -> bool {
    World::try_current(|_| ()).is_ok()
}

This uses the existing try_current method which already checks CURRENT.is_set() and returns a Result.

Option 2: Add a dedicated is_set() method to World

In src/world.rs:

pub(crate) fn is_set() -> bool {
    CURRENT.is_set()
}

Then in src/lib.rs:

pub fn in_simulation() -> bool {
    World::is_set()
}

[teskje]

Changed to option 1. I initially avoided this because I didn't like the additional overhead, but it's probably silly to worry about that here.