Allow TInstance<Self> to be used instead of decoupled pairs in the export macro

[chitoyuu]

From Endr on Discord:

It'd allow for more fine-grained control over how the object is borrowed in _process or other methods. It's sometimes convenient to pass down the instance to dependent objects. Currently the object has to be borrowed in the exported method, so others can't mutably borrow it through the instance. It can be workarounded with (Rc<RefCell<Data>>, TRef<Base>) pair, but it reimplements Instance in some way and adds more annoyances than needed.

Note that a TInstance interface is available using manual registration, although no example is readily available. It might be interesting to expand something like this into a full example project:

#[derive(Copy, Clone, Default)]
struct MyMethod;

#[derive(FromVarargs)]
struct Args {
    my_arg: i32,
    #[opt] my_opt_arg: Option<i32>,
}

impl StaticArgsMethod<MyScript> for MyMethod {
    type Args = Args;

    fn call(&self, this: TInstance<'_, MyScript>, args: Args) -> Variant {
        do_whatever_with(this);
        Variant::new(args.my_arg + args.my_opt_arg.unwrap_or(0))
    }

    fn site() -> Option<$crate::log::Site<'static>> {
        Some(godot_site!(MyScript::MyMethod))
    }
}

[Bromeon]

As an example:

// instead of:
#[method]
fn my_method(&mut self, #[base] base: &Node2D, arg: i32)

// it would be:
#[method]
fn my_method(#[instance] this: TInstance<'_, Self>, arg: i32)

Possibly with other names, e.g. #[this], #[self], ...

[chitoyuu]

#[self] might be a good option for this. It's short, convenient, and close to the arbitrary_self_types feature: https://doc.rust-lang.org/beta/unstable-book/language-features/arbitrary-self-types.html