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)
}
```
Because I was assuming that `Expr` was a `Spanned<Expr_>`. It actually isn't, which is surprising, and is apparently due to the need for a separate `id` field. Anyway, I'm guessing the following should work:

```rust
fn expand_cased(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree], transform: |char| -> char)
                        -> Box<base::MacResult> {
    let es = match base::get_exprs_from_tts(cx, sp, tts) {
        Some(e) => e,
        None => return base::DummyResult::expr(sp)
    };

    let mut it = es.iter();
    let res = match it.next() {
        // FIXME (#13910): nested matches are necessary to get through Gc<>
        Some(expr) => match expr.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(expr.span, "expected a string literal");
                None
            }
        },
        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)
        }
    }
}
```