Match destructuring in alternations should be generic over types

#![feature(globs)]

use Char::*;

enum Char {
    A(int),
    B(i32),
    C(char),
}
fn main(){ 
    let a = Char::A(7);

    // This match doesn't work because `x` changes type inside
    // one arm. The compiler should take this and generate an
    // equivalent of the second `match` example.
    match a {
        A(x) | B(x) | C(x) => println!("{}", x),
    }

    // This works because `x` doesn't change type inside an arm.
    match a {
        A(x) => println!("{}", x),
        B(x) => println!("{}", x),
        C(x) => println!("{}", x),
    }

}

Start from the two Rust match examples in the issue and investigate how alternation patterns currently type bindings across variants. Determine the language and compiler changes needed for bindings with differing types, then define the expected behavior and validation cases for equivalent matches.