Issue title: Patterns in extern fns either ICE or aren't type-checked
 Issue body: The following compiles fine, but uncommenting any of the currently-commented `extern` functions makes the compiler ICE.

``` rust
struct Foo { x: int }
extern {
    // fn foo(1: ());
    // fn bar((): int);
    // fn baz(Foo { x }: int);
    fn qux((x,y): ());
}
fn main() {}
```

For `foo` the ICE message is 

```
error: internal compiler error: node_id_to_type: no type for node `expr 1 (id=12)`
```

and the others are similar.

 Comments: 
 Comment 0: I'm inclined to say that the correct behavior is to deny all patterns other than `ident` (give a parser error perhaps).

 Comment 1: Nominating.

 Comment 2: @alexcrichton I agree

 Comment 3: Accepted for 1.0, P-backcompat-lang.

 Comment 4: Good newbie bug.

 Comment 5: Being a good newbie, I'll have a crack at this one. :)

 Comment 6: Might have aimed a little too high by trying this issue.. but from what i understand, the type checking is working as people would like, but the message is incorrect and should be a actual syntax error and not an ICE... so the below is some thing like how it should work?

``` rust
struct Foo { x: int }

extern {
    // This one should fail because you've supplied a literal as a fn arg with
    // no type
    fn foo(1: ());
    // This one should fail because you've specified '()' as a variable name for
    // the fn args
    fn bar((): int);
    // This one should pass because you've declared a deconstructed variable name
    // for the input parm 'x' and you've declared a type. This still should trigger
    // the warning for not using a 'li38d1:d2b4:3d06:83e8:96a5:8c2:893d:aba5c_int'.
    fn baz(Foo {x}: int);
    // This should pass because you've specified input parameters and rust will 
    // infer the type?
    fn qux((x,y): ());
}
```

Sorry if I've completely misunderstood, still pretty nubbins with Rust. :\

 Comment 7: @mankyKitty my reading of [acrichto's comment](#issuecomment-30111618) is that all of your examples should fail; ideally only an identfier should pass.

 Comment 8: They should all fail, the only thing that should pass is `fn foo(some_ident: int);`, nothing involving destructuring or pattern matching.

One way to implement this would be to make it an actual syntax error. You can find a starting place for this change by grepping for `ForeignItemFn` in `src/libsyntax/parse/parser.rs`. (I personally would recommend implementing this by threading a `require_ident_patterns_only` argument through `parse_fn_decl`, `parse_fn_args` to `parse_arg_general` where you chose between the existing `parse_pat` call and calling `parse_pat_ident` directly based on that boolean.)

> ```
> // This should pass because you've specified input parameters and rust will 
> // infer the type?
> fn qux((x,y): ());
> ```

No inference; this is always incorrect because you're trying to match a 2-tuple pattern (i.e. type `(T, U)`) in a slot of type `()` (i.e. nil, void, 0-tuple).

 Comment 9: @pnkfelix @huonw 

Ahhh okay, that makes more sense. Thanks for that. I'll see what I can make happen. 

{'source': 'GithubIssues', 'repo_name_with_owner': 'rust-lang/rust', 'issue_id': 23945370, 'repo_stars': 73938.0}