…le types, for now limited to same-sized integers.

This introduces the concept of equivalent/compatible/safely transmutable types.
This forms an equivalence class among types, as the safe transmutability must be mutual
(i.e. transmutable in both directions; no prefix-transmutability).

Thus, we can now allow ptr-to-ptr casts between safely transmutable pointee types,
whereas previously they were only allowed for equal types.
Equal types could have their `PointerId`s unified as they had the same structure,
which is still of safely transmutability types,
which are safely transmutability because they have the same structure/layout.

As safe transmutability is difficult to check abstractly for any two types,
for now we limit it to commonly transmuted types that we know are definitely transmutable:
same-sized integer types (with potentially different signedness).

Thus, this enables support for string casts like
`b"" as *const u8 as *const core::ffi::c_char`, where `c_char = i8`,
which fixes #840.

Note that the above cast (#833) is still not supported due to the string literal `b""` (#837),
but the cast itself (in `string_casts.rs` in `fn cast_only`) works.

…ible/safetly transmutable types, not identical.

… `a ~ b` => `*a ~ *b` for all `a`, `b`).

…e-way, now allowing for arrays and slices to decay.

This expands the definition of safe transmutability to be one-way.
That is, it checks if `*T as *U` is safe, rather than also `*U as *T`.

Thus, we can now allow for casts decaying
pointers to arrays and slices to pointers to their element type.

`do_unify` is modified to also be one-way,
which it was already in all call sites.

New tests are also added to `string_casts.rs`
for all the types of ptr-to-ptr casts.

Out of the full string cast, `b"" as *const u8 as *const core::ffi::c_char`,
this adds support for the `as *const u8` (from `&[u8; _]`),
so only support for the string literal itself remains.

… expanded defintion of safe transmutability.

…way, now allowing for arrays and slices to decay (#841)

Relaxed the transmutable checks from two-way to one-way, now allowing
for arrays and slices to decay.

This expands the definition of safe transmutability to be one-way. That
is, it checks if `*T as *U` is safe, rather than also `*U as *T`.

Thus, we can now allow for casts decaying pointers to arrays and slices
to pointers to their element type.

`do_unify` is modified to also be one-way, which it was already in all
call sites.

New tests are also added to `string_casts.rs` for all the types of
ptr-to-ptr casts.

Out of the full string cast, `b"" as *const u8 as *const
core::ffi::c_char`, this adds support for the `as *const u8` (from
`&[u8; _]`), so only support for the string literal itself remains.

…[A; N]`, `[A; N] => [A]`).

This fixes transmutability-related crashes in `tests/analyze/string_casts.rs`
(which weren't being actually run pre-`merge master` for some reason, and so were untested).

… string literals are also working (#886, #902).

…cker::do_unify` (back to strict equality) as #883 resolved this (#839 (comment)).

…#883.  It's not complete, but fixes the crash in `as_ptr.rs`.

…sion of the `cast_array_to_ptr` test. The other disabled tests still didn't work with the same approach.

…teral` test.

…icit` test b/c it still doesn't work even explicitly.

…sts to specify `&raw` MIR statements, inserted with `addr_of!`s.

…` formats it reasonably.

…ansitive" since it's non-symmetric, and equivalance relations are symmetric.

…fe transmutability for `CastKind::Misc`, which are the only non-type-checked ptr casts.

Note that `CastKind::Pointer(PointerCast::Unsize)` needs different rules than safe transmutability.
These rules are implemented by typeck, so there's no reason re-implementing that,
but we can't include them in transmutability (will be removed in the next commit).

…`[A] => [A; N]`, `[A; N] => [A]`)."

This reverts commit 182b0b5.

…s that cast is unsound and has been removed from transmutability in the last commit.

…to use well-defined instead of safe and to use "implies" instead of "and".

…rom `{pl,rv}_lty`, as they are interchangeable.

…` to the slice and array rules.

…han `N > 0` to avoid ZSTs, as then the rule would be unsound.

… it's only sound for non-empty slices, but we can't check that at compile-time.

…ngth `Const`s.

… docs.