core: avoid scoped dispatch overhead when scoped dispatchers are not in use

[hawkw]

Currently, the global default dispatcher is essentially implemented as a layer on top of the scoped default dispatcher. This means that using the global default dispatcher still pays some of the overhead of the scoped default dispatcher. In particular:

• Atomic reference counting. The global default dispatcher will never be dropped, as it lives for the entire lifetime of the program. However, we still Arc it, since the scoped default dispatcher requires Arcing. This means we have to bump a reference count to clone it that will never be 0. We could potentially change the internal representation to an enum of either Arc<dyn Subscriber + ...> (when scoped) or &'static dyn Subscriber + ... when global. That way, cloning the global dispatch is essentially free. This also means we could feature flag the Arc use, moving us one step closer to working on no_std targets without liballoc.

• Currently, we always check the thread-local storage for the scoped dispatcher before checking the global default. This is because a scoped default takes priority over a global default. However, this also means that getting the dispatch always involves a TLS hit, even when the TLS dispatcher is not being used. As I suggested here:

  [...] or because tracing requires an additional thread-local storage hit to check if there is a scoped dispatcher. A potentially worthwhile optimization is having a flag indicating whether scoped thread local dispatchers are in use, and skipping the TLS hit if it's unset...

  Originally posted by @hawkw in Tracing std::io::err performance #859 (comment)
  we could add a flag tracking whether any scoped default dispatchers exist, and skip checking TLS if it's unset. The easiest approach is just to have an AtomicBool flag that's set once a scoped dispatcher is created, and never unset --- this way, we would avoid checking TLS in programs that only use set_global_default (which is a fairly common case!). However, if we wanted to be fancier, we could also track a count of scoped default dispatchers. That would let us avoid checking TLS if scoped defaults are used briefly and then no longer used.

The additional complexity of this should, of course, be benchmarked.

[hawkw]

The overhead of adding an enum to dispatchers turns out to be more noticeable than one would have thought!