Add return value support to overload! macro

[Ajay-singh1]

Add return value support to overload! macro

Extends the overload! macro to support return values. Each overload
declares its own return type independently, via an associated type
Output on the generated trait:

trait FooArgs: std::marker::Tuple {
    type Output;
    fn call(self) -> Self::Output;
}

For example, this input:

overload! {
    fn foo(x: i32) -> i32 { x * 2 }
    fn foo(x: f64) -> f64 { x * 2.0 }
}

now generates:

trait FooArgs: std::marker::Tuple {
    type Output;
    fn call(self) -> Self::Output;
}

impl FooArgs for (i32,) {
    type Output = i32;
    fn call(self) -> i32 {
        let x = self.0;
        x * 2
    }
}

impl FooArgs for (f64,) {
    type Output = f64;
    fn call(self) -> f64 {
        let x = self.0;
        x * 2.0
    }
}

fn foo<T: FooArgs>(#[splat] args: T) -> T::Output {
    args.call()
}

Tested cases:

• Different return types per overload (i32 vs f64)
• Mixed argument shapes with the same return type
• Overloads with no return type mixed with overloads that do return
• Early return inside the function body
• Non-primitive return types (Vec, String)
• Non-Copy types moved out of the argument tuple
• Zero-argument overloads

Includes 8 example binaries with assert_eq! checks, added to the CI
runner list.

[teor2345]

This looks good, I'm just going to tweak a comment then merge. We can follow up the lint allows later.