Add syntax extensions for lowercasing/uppercasing strings (Fixes #16607)

Testcase:

```
 #![feature(macro_rules)]
macro_rules! identify (
  ($i: ident) => {
    let $i = to_lower!(stringify!($i));
  }
)

fn main() {
    println!("{}", to_lower!("FooBar"))
    println!("{}", to_lower!(stringify!(FooBar)))
    println!("{}", to_upper!("FooBar"))
    println!("{}", to_upper!(stringify!(FooBar)))
    identify!(FooBar);
    println!("{}",FooBar)
}
```
It occurs to me the `ref s` isn't going to work, since it's a reference to a moved value. We can skip the move, though, and we can also produce a better error for providing the wrong argument type vs not providing the right number of arguments. Something like:

```rust
let mut it = es.iter();
let res = match it.next() {
    Some(&codemap::Spanned { node: ast::ExprLit(ref lit), .. }) => match lit.node {
        ast::LitStr(ref s, span) => Some((s, span)),
        _ => {
            cx.span_err(span, "expected a string literal");
            None
        }
    },
    _ => {
        cx.span_err(sp, "expected 1 argument, found 0");
        None
    }
};
match (res,it.count()) {
    (Some((s,span)),0) => {
        let new_s = s.get().chars().map(transform).collect::<String>();
        base::MacExpr::new(cx.expr_str(sp, token::intern_and_get_ident(new_s.as_slice())))
    }
    (_, rest) => {
        if rest > 0 {
            cx.span_err(sp, format!("expected 1 argument, found {}", rest+1).as_slice());
        }
        base::DummyResult::expr(sp)
    }
}
```