This query computes the trait object, complete with associated type
projections for its supertraits, from a trait ref.

This is intended for use by CFI shimming.

In preparation to add recursive instance_defs, move this logic to its
own convenience method.

Factored out to minimize the amount of noise in the main CfiShim
defining patch.

We already use `Instance` at declaration sites when available to glean
additional information about possible abstractions of the type in use.
This does the same when possible at callsites as well.

The primary purpose of this change is to allow CFI to alter how it
generates type information for indirect calls through `Virtual`
instances.

Indirect calls through vtables (trait objects or drop_in_place) expect
to have an alias set based on `dyn Trait` at the call-site. The actual
implementations have aslias sets based on `MyImplType`. These shims create a
separate `InstanceDef`, allowing a different type to be assigned. These
function for both CFI and KCFI, as they have a single principal type.

Fixes: 118761

Rust will occasionally rely on fn((), X) -> Y being compatible with
fn(X) -> Y, since () is a non-passed argument. Relax CFI by choosing not
to encode non-passed arguments.

Current `transform_ty` attempts to avoid cycles when normalizing
`#[repr(transparent)]` types to their interior, but runs afoul of this
pattern used in `self_cell`:

```
struct X<T> {
  x: u8,
  p: PhantomData<T>,
}

 #[repr(transparent)]
struct Y(X<Y>);
```

When attempting to normalize Y, it will still cycle indefinitely. By
using a types-visited list, this will instead get expanded exactly
one layer deep to X<Y>, and then stop, not attempting to normalize `Y`
any further.

CFI shimming means they're not gauranteed to be pre-generated.
Traditionally, the base vtable has all the elements of the supertrait
vtable, and so visiting the base vtable implies you don't need to visit
the supertrait vtable. However, with CFI the base vtable entries will
have invocation type `dyn Child`, and the parent vtable will have
invocation type `dyn Parent`, so they aren't actually the same instance,
and both must be visited.

Additional trait bounds beyond the principal trait and its implications
are not possible in the vtable. This means that if a receiver is
`&dyn Foo + Send`, the function will only be expecting `&dyn Foo`.

This strips those auto traits off before CFI encoding.

In user-facing Rust, `dyn` always has at least one predicate following
it. Unfortunately, because we filter out marker traits and `dyn Sync`
is, for example, legal, this results in us having `dyn` types with no
predicates on occasion. This patch handles cases where there are no
predicates in a `dyn` type.