feat: Better thread local access

[Bluefinger]

The original implementation of ThreadLocalEntropy was based on rand's ThreadRng, making a few changes to not require reseeding or forking protection in order to assume cases more in-line with game application usage. However, as a result, it picked up the issues with the original implementation, such as leaking memory if the destructors for ThreadLocalEntropy didn't run.

This new implementation does away with cloning an Rc reference, instead opting for keeping the references within the LocalKey::with closure, avoiding any reference counting. The Rc prevents premature freeing during thread-local destructors, while keeping the ref inside the with closure ensures that we never end up in a situation where we might have a ref counted instance that never gets cleaned up.

This also apparently allows the compiler to make better optimisations with the thread local access. Normal release profile has the perf for the old implementation and new implementation around the same, with the new implementation slightly ahead for the worst case scenario and with better mean/median times. With codegen-units = 1 and LTO, it optimises considerably better.

NOTE: This is tuned for the specific usage of ThreadLocalEntropy within bevy_rand. For one time accesses with ThreadLocalEntropy that then use the RNG source before dropping, this implementation is much faster. For accesses that hold the reference for longer to be used repeatedly before dropping, the original ThreadRng implementation is faster. bevy_rand's case is more on the one-time accesses.