Missing precedence when several coercions are possible

As transitive coercions are at least partially supported, it currently doesn't seem to be clear which coercion(s) will be performed when there are several possibilities.

Consider the following code:

use std::ops::Deref;

struct A;
struct B;

impl Deref for A {
    type Target = B;
    fn deref(&self) -> &B {
        &B
    }
}

trait Trt {
    fn name(&self) -> &'static str;
}

impl Trt for A {
    fn name(&self) -> &'static str {
        "A"
    }
}

impl Trt for B {
    fn name(&self) -> &'static str {
        "B"
    }
}

impl dyn Trt {
    fn foo(&self) {
        println!("dyn {}", self.name());
    }
}

fn main() {
    let a = A;
    <dyn Trt>::foo(&a); // prints `dyn A`
     // but how can we deduce from the documentation that this doesn't happen internally?
    <dyn Trt>::foo(&a as &B as &dyn Trt);
}

(Playground)

See also this thread on URLO.

Start with the coercion example in the issue and run the linked Rust Playground case, then read the linked URLO discussion for the unresolved precedence question. Done means the Reference clearly explains which coercion is selected when several are possible and covers the demonstrated behavior.