Replace inline ASM with simd.

This has several advantages.

- it is faster in the microbenchmark (after a patch to rustc),
  presumably due to the fact the compiler has full control over data
  flow and data types, and so can arrange the loads optimally and avoid
  unnecessarily placing things onto the stack. It also means the
  compiler can see the SIMD vectors are always in the integer domain and
  so use (on x86) MOVDQA rather than the floating-point MOVAPS, avoiding
  the cross-domain penalties on platforms which have them.

- the library is now usable on x86 platforms without SSE2, and also on
  non-x86 platforms, possibly at a performance penalty (but maybe not,
  e.g. it may work with ARM's NEON), but this is better than not being
  usable at all.

- the danger and problems of `asm!` is completely removed, replaced with
  a pair of easy to verify `transmute`s.

Before:

    test bench_mt19937_1_000_000_rands ... bench:   1606892 ns/iter (+/- 57461)

After, with https://github.com/rust-lang/rust/pull/19294:

    test bench_mt19937_1_000_000_rands ... bench:   1539038 ns/iter (+/- 33623)

Without that patch it takes `2787449 ns/iter`.

The last of the three (essentially identical) inner loops of the
benchmark are given below. They demonstrate the advantages listed above.

Before:

    .LBB2_6:
    	movaps	3056(%rax,%rdx), %xmm2
    	movaps	1872(%rax,%rdx), %xmm3
    	movaps	%xmm2, (%rsp)
    	#APP
    	psllq	$19, %xmm2
    	pxor	%xmm3, %xmm2
    	pshufd	$27, %xmm1, %xmm1
    	pxor	%xmm2, %xmm1
    	movaps	%xmm1, %xmm2
    	movaps	%xmm1, %xmm3
    	pand	%xmm0, %xmm2
    	psrlq	$12, %xmm3
    	pxor	(%rsp), %xmm3
    	pxor	%xmm2, %xmm3
    	#NO_APP
    	movaps	%xmm3, 3056(%rax,%rdx)
    	addq	$16, %rdx
    	jne	.LBB2_6

After:

    .LBB2_4:
    	movdqa	3056(%rax,%rdx), %xmm2
    	pshufd	$27, %xmm1, %xmm3
    	movdqa	%xmm2, %xmm1
    	psllq	$19, %xmm1
    	pxor	1872(%rax,%rdx), %xmm1
    	pxor	%xmm3, %xmm1
    	movdqa	%xmm1, %xmm3
    	psrlq	$12, %xmm3
    	movdqa	%xmm1, %xmm4
    	pand	%xmm0, %xmm4
    	pxor	%xmm3, %xmm4
    	pxor	%xmm2, %xmm4
    	movdqa	%xmm4, 3056(%rax,%rdx)
    	addq	$16, %rdx
    	jne	.LBB2_4
Fix reversed loop bug.

`range_inclusive` always counts up, so `range_inclusive(1, 0)` is an
empty iterator. A correct way to iterate downwards is
`range_inclusive(0, 1).rev()`, that is, take an iterator `[0, 1]` and
run it backwards.
Add `black_box` calls to avoid f64 generation disappearing.

The final steps of generating an `f64` are fairly pure, and LLVM can see
this, so it just removes it, since the result is unused. The `black_box`
function is designed to manually overcome this, making the benchmarks
more representative.

Before:

    test bench_isaac64_1_000_000_rands ... bench:   6028930 ns/iter (+/- 133191)
    test bench_mt19937_1_000_000_rands ... bench:   1538384 ns/iter (+/- 43405)
    test bench_xor_1_000_000_rands     ... bench:   2368067 ns/iter (+/- 68618)

After:

    test bench_isaac64_1_000_000_rands ... bench:   6580334 ns/iter (+/- 199685)
    test bench_mt19937_1_000_000_rands ... bench:   3216404 ns/iter (+/- 84669)
    test bench_xor_1_000_000_rands     ... bench:   4135769 ns/iter (+/- 175282)