std::rand: move the Isaac implementation to its own file.
std::rand: Add an implementation of ISAAC64.

This is 2x faster on 64-bit computers at generating anything larger
than 32-bits.

It has been verified against the canonical C implementation from the
website of the creator of ISAAC64.

Also, move `Rng.next` to `Rng.next_u32` and add `Rng.next_u64` to
take full advantage of the wider word width; otherwise Isaac64 will
always be squeezed down into a u32 wasting half the entropy and
offering no advantage over the 32-bit variant.
std::rand: Add OSRng, ReaderRng wrappers around the OS RNG & generic Readers respectively.

The former reads from e.g. /dev/urandom, the latter just wraps any
std::rt::io::Reader into an interface that implements Rng.

This also adds Rng.fill_bytes for efficient implementations of the above
(reading 8 bytes at a time is inefficient when you can read 1000), and
removes the dependence on src/rt (i.e. rand_gen_seed) although this last
one requires implementing hand-seeding of the XorShiftRng used in the
scheduler on Linux/unixes, since OSRng relies on a scheduler existing to
be able to read from /dev/urandom.
std::rand: add the StdRng wrapper for a blessed RNG.

This is implemented as a wrapper around another RNG. It is designed
to allow the actual implementation to be changed without changing
the external API (e.g. it currently uses a 64-bit generator on 64-
bit platforms, and a 32-bit one on 32-bit platforms; but one could
imagine that the IsaacRng may be deprecated later, and having this
ability to switch algorithms without having to update the points of
use is convenient.)

This is the recommended general use RNG.
std::rand: Add ReseedingRng, which will reseed an RNG after it generates a certain number of bytes.

It is an "RNG adaptor" and so any RNG can be wrapped to have this behaviour.
std::rand: Add a trait for seeding RNGs: SeedableRng.

This provides 2 methods: .reseed() and ::from_seed that modify and
create respecitively.

Implement this trait for the RNGs in the stdlib for which this makes
sense.
std::rand: improve the task_rng code.

It now:
- can be explicitly seeded from user code (`seed_task_rng`) or from the
  environment (`RUST_SEED`, a positive integer)
- automatically reseeds itself from the OS *unless* it was seeded by
  either method above
- has more documentation
std::rand: make the windows OSRng more correct, remove some C++.

This lets the C++ code in the rt handle the (slightly) tricky parts of
random number generation: e.g. error detection/handling, and using the
values of the `#define`d options to the various functions.
std::rand: add & split some tests.
std::rand: move the Rand impls into a separate file for neatness.
std::rand: documentation additions & fixes.
std::rand: adjust the f32 & f64 Rand instances.

The f32 generator now just uses a single u32, and the f64 uses a
single u64. This will make both significantly faster, especially
on 64-bit platforms.
Convert rt::sched::new_sched_rng to use open/read/close rather than f*.
std::rand: remove `seed`.

This much better handled by directly calling out to `OSRng` where
appropriate.
Documentation & address minor point.
std::rand: Correct the implementation of Rand for f32 & f64.
std::rand::reader: describe cfg!(endianness).
std::rand::reseeding: seed the reseeder in the SeedableRng impl.

This stops us relying on Default here.
std::rand::os: use the externfn! macro for the Windows RNG.
std::rand: Make Rng.next_u32 non-default, waiting for #7771.