Allow the trait checker to attempt Deref before giving up

Fairly self explanatory but it could be a partial solution to #2393 before it is implemented in the rust compiler

Suppose you have some code

use std::ops::Deref;

trait Foo { fn foo(&self); }

struct Bar { }
impl Foo for Bar {
  fn foo(&self) { }
}

fn baz<T: Foo> (_: &T) { }

struct WrapBar { wbar: Bar }

impl Deref for WrapBar {
  type Target = Bar;
  fn deref(&self) -> &Self::Target { &self.wbar }
}

fn main() {
  let b = WrapBar { wbar: Bar {} };
  // explicit call via &Bar
  &b.wbar.foo();
  // implicit Deref to &Bar before call, hooray https://doc.rust-lang.org/reference/expressions/method-call-expr.html
  &b.foo();
  // succeeds because WrapBar can be Deref'd to Bar because we are aware of baz::<Bar> having the signature &Bar -> ()
  baz::<Bar>(&b);
  // fails because WrapBar does not implement Foo because baz has signature &(T: Foo) -> ()
  // baz(&b);
}

Maybe we can amend rust-lang/rfcs#241 so that the compiler tries Deref coercion for function arguments with unsolved traits as well.

If this is a dumb idea then feel free to just close this.

Start with the Rust example in this issue, then read RFC 241 and the referenced issue #2393 to understand the proposed trait-checking and Deref behavior. Done would mean a clear, accepted direction for whether function arguments with unsolved traits should attempt Deref coercion; no implementation files or tests are identified here.