Add a cfg_attr syntax extension

This extends cfg-gating to attributes.

```rust
#[cfg_attr(<cfg pattern>, <attr>)]
```
will expand to
```rust
#[<attr>]
```
if the `<cfg pattern>` matches the current cfg environment, and nothing
if it does not. The grammar for the cfg pattern has a simple
recursive structure:

 * `value` and `key = "value"` are cfg patterns,
 * `not(<cfg pattern>)` is a cfg pattern and matches if `<cfg pattern>`
    does not.
 * `all(<cfg pattern>, ...)` is a cfg pattern and matches if all of the
    `<cfg pattern>`s do.
 * `any(<cfg pattern>, ...)` is a cfg pattern and matches if any of the
    `<cfg pattern>`s do.

Examples:

```rust
// only derive Show for assert_eq! in tests
#[cfg_attr(test, deriving(Show))]
struct Foo { ... }

// only derive Show for assert_eq! in tests and debug builds
#[cfg_attr(any(test, not(ndebug)), deriving(Show))]
struct Foo { ... }

// ignore a test in certain cases
#[test]
#[cfg_attr(all(not(target_os = "linux"), target_endian = "big"), ignore)]
fn test_broken_thing() { ... }

// Avoid duplication when fixing staging issues in rustc
#[cfg_attr(not(stage0), lang="iter")]
pub trait Iterator<T> { ... }
```

I also deprecated the `#[ignore(cfg(...))]` syntax in favor of `#[cfg_attr(..., ignore)]`.

I think this cfg pattern syntax is a good system to move `#[cfg(...)]` to as well, but that should probably go through an RFC first.
Perhaps this whole series of `MetaList` matches could be refactored slightly:

```rust
match cfg.node {
    ast::MetaList(ref pred, ref mis) => {
        match pred.get() {
            "any" => mis.iter().any(|mi| cfg_matches(cx, *mi)),
            "all" => mis.iter().all(|mi| cfg_matches(cx, *mi)),
            "not" if mis.len() == 1 => !cfg_matches(cx, mis[0]),
            "not" => {
                cx.span_err(cfg.span, format!("expected 1 value, got {}", mis.len()).as_slice());
                false
            }
            _ => {
                cx.span_err(cfg.span, format!("invalid predicate `{}`", pred).as_slice());
                false
            }
        }
    }
    ast::MetaWord(_) | ast::MetaNameValue(..) => atr::contains(cx.cfg.as_slice(), cfg)
}
```

This rewrite also fixes two more nitpicks. The first is you're unnecessarily wrapping early (our current guidelines give you 99 characters for a line). The second is you needed braces on the final arm as well.