Feature request: Function to join thread with timeout

A somewhat niche, but still occasionally useful feature is the ability to join a thread with a timeout, i.e. wait for a thread to join until a timeout is reached. It would be nice if this was included in the standard library, since trying to write an external crate for this is fairly convaluted, because the thread management logic is tightly coupled to the standard library.

I propose adding a function that allows this to std::thread::JoinHandle and std::thread::ScopedJoinHandle.
The API could look approximately like this:

impl<T> JoinHandle<T> {
    pub fn join_timeout(self, duration: Duration) -> Result<T, JoinTimeoutError<T>> {
        todo!()
    }
}

pub enum JoinTimeoutError<T> {
    Panic(Box<dyn Any + Send + 'static>),
    Timeout(JoinHandle<T>),
}

Returning the JoinHandle on timeout might be a little clunky, but it is the only way I could think of to enforce that join_timeout isn't called again after it succeeds. Alternatively join_timeout could take &mut self and then return a third enum variant or panic to indicate that the thread has already been joined.

I don't know how difficult this would be to implement for all supported platforms, but similar functions are included in (among others) Python, Java, C# and POSIX threads, so it should at least be possible on all major platforms.

Start with the std:🧵:JoinHandle and std:🧵:ScopedJoinHandle entry points described in the issue, then review how thread joining is handled across supported platforms. Resolve the timeout API and error behavior, including what happens after a timeout, and ensure the feature works consistently on those platforms.