libstd: impl Num for BigUint/BigInt
libstd: impl `Orderable` for `BigUint`/`BigInt`
libstd: `Rational` requires `Integer` as type bounds instead of `Num`
libstd: `Ratio` requires `Clone` instead of `Copy`

This allows creating `Ratio<T>` which `T` is non-implicitly copyable types
such as `BigInt`.
libstd: Add tests for BigRational
Replace shared/unique by managed/owned in the tutorial
Add inlining for iter_bytes for types used as hashmap keys

Not inlining these affects the hash table performance quite badly.
testsuite: Update and un-xfail unsafe-fn-autoderef
Add Scheme-style `cond!` macro to syntax::ext::expand

Addresses issue #6037
auto merge of #6471 : gifnksm/rust/reform-rational, r=brson

`std::ratio` module contains `BigRational` type, but the type is not usable by following reasons.
* `Ratio::new` requires `T: Copy + Num + Ord`, but `BigInt` is not implicitly copyable, because it contains unique vector.
* `BigInt` is not implements `Num`

So, I rewrite `Ratio` as follows.
* `Ratio` requires `T: Clone + Integer + Ord`.
  * `Copy` -> `Clone`: to be able to use `BigRational`
  * `Num` -> `Integer`: It is incorrect that a rational number constructed by two non-integer numbers.
* `BigInt` implements `Num` and `Orderable` which are required by `Integer` bound
Better error reporting with renaming imports
Add test for resolution errors
Add span to some import resolution errors
Get span from import_directive
Fix ICE
Fix resolution tests
Use parentheses for cond! macro instead of preceding pipes

This is temporary. Once the macro parser has improved or been re-written these can be removed.
auto merge of #6333 : bjz/rust/cond-macro, r=thestinger

Addressing issue #6037, this Scheme-style conditional helps to improve code clarity in instances where the `if`, `else if`, and `else` keywords obscure predicates undesirably.

Here is an example:

~~~rust
let clamped =
    if x > mx { mx }
    else if x < mn { mn }
    else { x };
~~~

Using `cond!`, the above could be written as:

~~~rust
let clamped = cond!(
    (x > mx) { mx }
    (x < mn) { mn }
    _        { x  }
);
~~~

The optional default case is denoted by `_`.

I have altered `std::fun_treemap` to demonstrate it in use. I am definitely interested in using it for some of the numeric functions, but I will have to wait for it to reach `stage0` first.
auto merge of #6475 : sonwow/rust/tutorials, r=brson
rustc: minor cleanup