core: remove mandatory liballoc dependency with no-std

[hawkw]

Motivation

Presently, tracing and tracing-core allow disabling the Rust
standard library. However, even when used with the standard library
disabled, they still require the use of alloc, which means some form
of global allocator must exist. This can be a significant limitation on
some very constrained embedded devices. Additionally, the use of any
heap allocations on these devices ought to be avoided.

Now that the callsite registry is no longer a Vec, we don't need heap
allocations for storing registered callsites. However, Dispatchs are
currently always stored in Arcs, and the global registry always
contains a Vec of Weak refs to them. This is required in order to
support thread-local scoped dispatcher API, where multiple Dispatches
can coexist. However, on no-std platforms without threads, we already
don't support the thread-local scoped dispatch API. In this case, we can
reduce the complexity and the number of allocations required by the
dispatcher.

Additionally, even when the standard library is in use, if the
dispatcher is a global default rather than a scoped dispatcher, it
remains set forever. This means it can never be dropped. When this is
the case, it's possible to clone the dispatcher by cloning a 'static
reference, rather than a (comparatively) costly Arc bump.

Solution

This branch changes the global default dispatcher to be represented as a
&'static dyn Subscriber reference on all platforms. In addition, the
dependency on liballoc is now feature flagged, allowing it to be
disabled along with the dependency on libstd. This means that
tracing can now be used with no heap allocations required.

In order to use tracing without liballoc, Dispatches can only be
created from &'static dyn Subscriber references, since this is the
only way to erase their types that exists without boxed trait objects.
Therefore, I've added a new Dispatch::from_static constructor that is
always available. This is more limiting than Dispatch::new --- some
ways of modeling runtime composition of the subscriber are much harder
(although it could still contain state). However, users without alloc
are probably fairly used to this --- the log crate has the same
limitation when used
without std.

Also, I've changed the global subscriber registry when std is
enabled to use a RwLock rather than a mutex. Now, multiple callsites
can be registered simultaneously, and a write lock is only necessary to
add a new subscriber or deregister old ones. It's now fine to use
RwLock here, because we no longer use any locking at all when std is
not enabled --- we always use the single global default subscriber, so
we don't require a list of currently live subscribers.

I've modified the tracing and tracing-core crates to add new feature
flags for enabling std and alloc separately.

Closes #861

[hawkw]

cc @Hoverbear, @steveklabnik, and any other potential no_std users

[LucioFranco]

LGTM; Only small nits, and do we have CI checking this?

[LucioFranco]

should we just link to core's docs here rather than repeating?

[hawkw]

i think it's likely that more people will be reading the tracing docs than the tracing-core ones, so i thought it was better to reproduce it here...@davidbarsky wdyt?

[davidbarsky]

I'd rather reproduce here for now.

[steveklabnik]

siiiick excited to give this a try!