Implement Varargs

[fcard]

This adds the special Vararg! "macro" (really just a marker) which allows the creation of variadic methods, i.e. methods that take a variable number of arguments. The "vararg" variable collects the optional arguments in a Vararg<T> type, which implements IntoIterator as a value, a reference and a mutable reference, as well as Index and IndexMut for SliceIndex<[T]> (making it sort of like a fixed-length vector)

Example:

multifunction! {
  fn MAX(args: Vararg![i32]) -> Option<i32> {
    args.iter().max().map(|x| *x)
  }
}

fn main() {
  println!("{:?}", MAX(1,2,3)); // Some(3)
  println!("{:?}", MAX(1));     // Some(1)
  println!("{:?}", MAX());      // None
}

This is a pretty silly implementation, since it just adds a method for each possible number of extra arguments, e.g. the MAX function above has 13 methods, one for zero, another for one, another for two.. until twelve. Since method can only have up to 12 arguments currently, the total number of methods is (13 - the number of required arguments). This will have to do until Variadic Generics are implemented. (rust-lang/rfcs#376, rust-lang/rfcs#1935)

Also of note is the interaction between varargs and other methods.

multifunction! {
  fn F(args: Vararg![]) {
    println!("Least specific")
  }

  fn F(arg: Abstract![ANY], args: Vararg![]) {
    println!("Middling")
  }

  fn F(arg: i32, args: Vararg![]) {
    println!("Most specific")
  }
}

fn main() {
  F();     // Least specific
  F("a");  // Middling
  F(1i32); // Most Specific
}