Make connect implementations clearer by using vector destructuring
Begin implementing Interpolate trait

For the moment this includes only a lerp method. This trait should be expanded to be more comprehensive in the future.
Interpolation code

Implements

 - Linear
 - Cosine
 - Smooth (Based on Smooth Step)
 - Barycentric
 - Hermite
 - Cubic
 - Catmull-Rom

They are implemented using Horner's rule, which should be the fastest
assuming that we cannot get any parallelism. At some later date we can
see if we could optimize them for super-scalar processors.

TODO: Add documentation, tests and make the implementation generic.
Added tests for num::Interpolate

It just tests edge cases, but the actual results should vary with the
availability of fast FMA so I am not testing them right now.
'Pub-ify' numeric methods
Add error functions to Real
Remove free-standing functions from numeric modules and stop rexporting delegated f64/f32 functions

These should now be covered by methods in the numeric traits
A simple copy-paste error found by unit-testing
Redesign the basic tests for barycentric

The original tests were not accurate in double-precision, but I must
have forgotten to run the tests in double-precision so I never noticed
that.

The new tests are designed to be accurate in all sensible IEEE 754
precisions, including half-precision.
auto merge of #6986 : bjz/rust/interpolate, r=brson

As part of #4819, this commit removes most of the free-standing wrapper functions from the numeric modules. It also removes the re-exports of the delegated intrinsic and cmath functions in `std::{float, f32, f64}`.

What does this mean from a user perspective? Most of the functions you normally use are now covered by methods in the numeric trait hierarchy. For example, `f32::sin(2.0)` would now be written as `2.0f32.sin()`, or `int::min(1, 2)` as `1i.min(&2)` (unfortunately the explicit type suffix is needed because Rust can't infer the type).

@jensnockert has also added an `Interpolate` trait to `std::num` implemented for `float`, `f64` and `f32`. This adds the following associated functions:

~~~rust
pub trait Interpolate {
    pub fn linear(x: Self, y: Self, t: Self) -> Self;
    pub fn cosine(x: Self, y: Self, t: Self) -> Self;
    pub fn smooth(x: Self, y: Self, t: Self) -> Self;
    pub fn barycentric(x: Self, y: Self, z: Self, t0: Self, t1: Self) -> Self;
    pub fn hermite(x: Self, xp: Self, y: Self, yp: Self, t: Self) -> Self;
    pub fn cubic(x: Self, y: Self, z: Self, u: Self, t: Self) -> Self;
    pub fn catmull_rom(x: Self, y: Self, z: Self, u: Self, t: Self) -> Self;
}
~~~

In addition, I have also added the [error functions](http://en.wikipedia.org/wiki/Error_function) to `std::num::Real`:

~~~rust
pub trait Real {
    //...
    
    pub fn erf(&self) -> Self;
    pub fn erfc(&self) -> Self;

    // ...
}
~~~