Add std::iterator::order with lexical ordering functions for sequences

Use Eq + Ord for lexicographical ordering of sequences.

For each of <, <=, >= or > as R, use::

    [x, ..xs] R [y, ..ys]  =  if x != y { x R y } else { xs R ys }

Previous code using `a < b` and then `!(b < a)` for short-circuiting
fails on cases such as  [1.0, 2.0] < [0.0/0.0, 3.0], where the first
element was effectively considered equal.
extra::dlist: Use iterator::order for sequence ordering
std: Implement traits for the one-tuple

(A,) did not have the trait implementations of 2- to 12- tuples.
std::vec: Use iterator::order functions for Eq, Ord, TotalOrd, TotalEq
std: Fix Ord for Option, using iterator::order
std: Fix tuple lexicographical order

Use the definition, where R is <, <=, >=, or >

    [x, ..xs] R [y, ..ys]  =  if x != y { x R y } else { xs R ys }

Previously, tuples would only implement < and derive the other
comparisons from it; this is incorrect. Included are several testcases
involving NaN comparisons that are now correct.

Previously, tuples would consider an element equal if both a < b and
b < a were false, this was also incorrect.
std::iterator::order test cases
std::vec: Fix typo in fn ne
std::tuple: Use != properly in Eq::ne for tuples

Just like the Ord methods, Eq::ne needs to be implemented in terms of
the same operation on the elements.
Remove rtdebug_! and make rtdebug! work properly.

It now actually does logging, and is compiled out when `--cfg rtdebug` is not
given to the libstd build, which it isn't by default. This makes the rt
benchmarks 18-50% faster.
docs: In rustpkg manual, note future plans about versions
auto merge of #8429 : catamorphism/rust/rustpkg-docs, r=catamorphism
auto merge of #8400 : blake2-ppc/rust/seq-ord, r=cmr

Use Eq + Ord for lexicographical ordering of sequences.

For each of <, <=, >= or > as R, use::

    [x, ..xs] R [y, ..ys]  =  if x != y { x R y } else { xs R ys }

Previous code using `a < b` and then `!(b < a)` for short-circuiting
fails on cases such as  [1.0, 2.0] < [0.0/0.0, 3.0], where the first
element was effectively considered equal.

Containers like &[T] did also implement only one comparison operator `<`,
and derived the comparison results from this. This isn't correct either for
Ord.

Implement functions in `std::iterator::order::{lt,le,gt,ge,equal,cmp}` that all
iterable containers can use for lexical order.

We also visit tuple ordering, having the same problem and same solution
(but differing implementation).
auto merge of #8419 : cmr/rust/fix-rtdebug, r=brson

It now actually does logging, and is compiled out when `--cfg rtdebug` is not
given to the libstd build, which it isn't by default. This makes the rt
benchmarks 18-50% faster.
remove the Times trait in favour of `range`

It's not possible to break from `times` and it results in the
restrictions coming from closures. Using `for _ in range(0, n)` from the
start is simpler, rather than switching to it after hitting either of
these issues.