typeck: boxed closures can't capture by value

[japaric]

closes #19141
closes #20193
closes #20228

---

Currently whenever we encounter let f = || {/* */}, we always type check the RHS as a boxed closure. This is wrong when the RHS is move || {/* */} (because boxed closures can't capture by value) and generates all sort of badness during trans (see issues above). What we should do is always type check move || {/* */} as an unboxed closure, but I think (haven't tried) (2) this is not feasible right now because we have a limited form of kind (Fn vs FnMut vs FnOnce) inference that only works when there is an expected type (1).

In this PR, I've chosen to generate a type error whenever let f = move || {/* */} is encountered. The error asks the user to annotate the kind of the unboxed closure (e.g. move |:| {/* */}). Once annotated, the compiler will type check the RHS as an unboxed closure which is what the user wants.

r? @nikomatsakis

(1) AIUI it only triggers in this scenario:

fn is_uc<F>(_: F) where F: FnOnce() {}

fn main() {
    is_uc(|| {});  // type checked as unboxed closure with kind `FnOnce`
}

(2) I checked, and it's not possible because check_unboxed_closure expects a kind argument, but we can't supply that argument in this case (i.e. let f = || {}, what's the kind?). We could force the FnOnce kind in that case, but that's ad hoc. We should try to infer the kind depending on how the closure is used afterwards, but there is no inference mechanism to do that (at least, not right now).