Fix how negative literals are handled to be in line with Rust

[udoprog]

Literals are resolved internally to num::BigInt, so they have no size limitation at compile time. Only at the point that they are treated as something, like a tuple index (usize) or a literal number (i64).

This fixes parsing so that it is in line with Rust. This has been an outstanding issue with the quote! macro, in that -10 would be treated as - 10 (note the space), which wouldn't parse. Now it does parse.

This has the nice side effect that the rune! macro can mostly just consume a token stream from Rust now, since Rune mostly accepts the same stringified tokens as Rust. So many test cases now look like this:

assert_eq! {
    rune!(bool => fn main() { false || false || {return true; false} || false }),
    true,
};

Note: this currently "cheats" by calling stringify!, but could just as well use quote! internally.

The exception is the ones dealing with string templates, since they are whitespace sensitive and have no corollary in Rust. For these we maintain the rune_s! test macro that works like rune! did before:

assert_eq! {
    rune_s! { String => r#"
        fn main() {
            let name = "John Doe";
            `Hello {name}, I am {1 - 10} years old!`
        }
    "#},
    "Hello John Doe, I am -9 years old!",
};

This also changes a bunch of the plumbing for ast::Pat, since these used to rely on literals parsing in a different manner. Of note is that they also parse attributes now.