rustc: Don't deduplicate libraries linked to

Linker argument order with respect to libraries is important enough that we
shouldn't be attempting to filter out libraries getting passed through to the
linker. When linking with a native library that has multiple dependant native
libraries, it's useful to have control over the link argument order.
Add the DerefImm and DerefMut traits.
Implement DerefImm for Rc and DerefImm/DerefMut for RefCell's Ref/RefMut.
Allow overloading explicit dereferences.
auto merge of #12697 : thestinger/rust/vec, r=huonw

This exists for the sake of compatibility during the ~[T] -> Vec<T>
transition. It will be removed in the future.
Expand nested items within a backtrace.

Fixes a regression from #4913 which causes items to be exanded with spans lacking expn_info from the context's current backtrace.
Rename all variables that have uppercase characters in their names to use only lowercase characters
Add lint for variable names that contain uppercase characters
Rename struct fields with uppercase characters in their names to use lowercase
auto merge of #12688 : alexcrichton/rust/fix-some-link-args, r=brson

Linker argument order with respect to libraries is important enough that we
shouldn't be attempting to filter out libraries getting passed through to the
linker. When linking with a native library that has multiple dependant native
libraries, it's useful to have control over the link argument order.
auto merge of #12671 : nick29581/rust/expand, r=sfackler

Fixes a regression from #4913 which causes items to be exanded with spans lacking expn_info from the context's current backtrace.
Allow uppercase_variables in libstd/libc.rs
Emit the uppercase variable lint for struct fields that have names with uppercase characters
auto merge of #12300 : DaGenix/rust/uppercase-variable-lint, r=alexcrichton

I added a new lint for variables whose names contain uppercase characters, since, by convention, variable names should be all lowercase. What motivated me to work on this was when I ran into something like the following:

```rust
use std::io::File;
use std::io::IoError;

fn main() {
    let mut f = File::open(&Path::new("/something.txt"));
    let mut buff = [0u8, ..16];
    match f.read(buff) {
        Ok(cnt) => println!("read this many bytes: {}", cnt),
        Err(IoError{ kind: EndOfFile, .. }) => println!("Got end of file: {}", EndOfFile.to_str()),
    }
}
```

I then got compile errors when I tried to add a wildcard match pattern at the end which I found very confusing since I believed that the 2nd match arm was only matching the EndOfFile condition. The problem is that I hadn't imported io::EndOfFile into the local scope. So, I thought that I was using EndOfFile as a sub-pattern, however, what I was actually doing was creating a new local variable named EndOfFile. This lint makes this error easier to spot by providing a warning that the variable name EndOfFile contains a uppercase characters which provides a nice hint as to why the code isn't doing what is intended.

The lint warns on local bindings as well:

```rust
let Hi = 0;
```

And also struct fields:

```rust
struct Something {
    X: uint
}
```
auto merge of #12491 : eddyb/rust/deref, r=nikomatsakis

Add the `Deref` and `DerefMut` traits and implement overloading explicit dereferences.
Str::slice_chars() is O(end), not O(end - begin)
auto merge of #12708 : SimonSapin/rust/patch-6, r=huonw

Feel free to reject this if I’m mistaken, but the `count` in the for loop does look like it’s going from 0 to `end`.
create a sensible comparison trait hierarchy

* `Ord` inherits from `Eq`
* `TotalOrd` inherits from `TotalEq`
* `TotalOrd` inherits from `Ord`
* `TotalEq` inherits from `Eq`

This is a partial implementation of #12517.
`std::min` and `std::max` require `TotalOrd`

The `Float` trait now provides `min` and `max` methods, which should be
used instead for floating point types.

Closes #12712