Change the encoding of supertrait clauses to support associated types

[lukenels]

This pull request is related to the discussion in #87.

When auto_impl is used to implement trait that has a supertrait, it needs to enforce that the inner type already implements the supertrait. However, the current encoding does not work correctly when the supertrait has an associated type that the subtrait refers to in one of its methods.

To make this concrete, take the following example.

use auto_impl::auto_impl;

pub trait Foo {
    type MyType;
}

pub trait Bar: Foo {
    fn bar(&self, value: Self::MyType);
}

auto_impl will expand this code into the following, which fails to compile since the compiler doesn't know that Arc<T>::Foo is the same type as T::Foo.

pub trait Foo {
    type MyType;
}

pub trait Bar: Foo {
    fn bar(&self, value: Self::MyType);
}

const _: () = {
    extern crate alloc;
    impl<T: Bar + ?Sized> Bar for alloc::sync::Arc<T>
    where
        alloc::sync::Arc<T>: Foo,
    {
        fn bar(&self, value: Self::MyType) {
            T::bar(self, value)
        }
    }
};

This commit changes how auto_impl encodes supertrait where constraints like alloc::sync::Arc<T>: Foo to refer to the inner type parameter instead, e.g., T: Foo. With this change, if we also annotate trait Foo with auto_impl, then the associated type example will compile, because the compiler has access to the implementation of Foo for Arc<T> when T: Foo:

use auto_impl::auto_impl;

pub trait Foo {
    type MyType;
}

pub trait Bar: Foo {
    fn bar(&self, value: Self::MyType);
}

This change is not backwards compatible in certain edge scenarios. For example, the new encoding does not permit using auto_impl to implement Bar for Arc<T> but having a user-defined / custom implementation of Arc<T> for its supertrait Foo.

It also causes auto_impl on Bar to fail to compile eagerly when there is no corresponding implementation of Foo, whereas the previous behavior would allow this to compile (but would produce a constraint that fails to be satisfied if the implementation of Bar is ever attempted to be used).

These seem like niche scenarios, but this does constitute a functional (though minor) change. However, this this trade-off may be worth since it's otherwise not possible to use associated types from supertraits with auto_impl.

This commit also updates the unit tests accordingly; for example, adding auto_impl on supertraits where it was missing before in order to fix the new build errors.