* The C implementation of `Host` is renamed to `HostCInternal` and its
  methods `host_*` renamed to `hostc_*`. This type and these methods are
  now meant only to be used from the Rust `Host`.
* The Rust `Host` is now the canonical `Host` type. It is currently not much
  more than a wrapper around a `HostCInternal`, with the `host_*` methods
  implemented by calling their original `hostc_*` implementations, but we
  should now be able to start moving fields from `HostCInternal` to `Host`,
  and start replacing the thin proxy methods with Rust native implementations.
* The `Host` now has a `Root` object that we can use for cheap interior
  mutability and reference counting of objects associated with that `Host`.
* `Host` is no longer ref-counted. There is no longer a `host_ref` nor
  `hostc_ref`. This is because `Host` is `!Sync`, so could not be stored
  inside a ref-counted wrapper without re-adding a `Host` lock wrapper
  to make it `Sync`. e.g. it would need to be something like an
  `Arc<AtomicRefCell<Host>>`. While the extra locking overhead in the scheduler
  probably wouldn't be that noticeable, make it difficult to make access to the
  `&Host` or its internal `&Root` cheaply globally accessible.
* A reference to the current `Host` can now be retrived from the `Worker` via
  `Worker::with_active_host`. This lets us get to the `Host` from places
  that previously fetched it from a stored pointer.
* `Host` methods now all take `&Host`; there are no `&mut Host` methods.
  With so much inside the `Host`, and since we want to be able to access it via
  a global (at least for now), anything holding a `&mut Host` would prevent
  anything else being able to retrieve any reference to the `Host`.
* We do the same with the `Worker`, for analagous reasons.
* The scheduler now moves the `Host` value instead of passing a `&Host`.
  This allows the `Host` to be stored in the `Worker`'s thread-local,
  and borrowed as-needed via `Worker::with_active_host`.

This allows us to remove the previously unsound api Host::random, which
returned a mutable reference from an immutable reference without using
interior mutability.

Rather than trying to expose the Rng directly to C, with the needed
function object, we implement the rng APIs that the C code needs
directly on the Host.

After this change we no longer need the Random C APIs, so those are
removed.