Auto merge of #96094 - Elliot-Roberts:fix_doctests, r=compiler-errors

Begin fixing all the broken doctests in `compiler/`

Begins to fix #95994.
All of them pass now but 24 of them I've marked with `ignore HELP (<explanation>)` (asking for help) as I'm unsure how to get them to work / if we should leave them as they are.
There are also a few that I marked `ignore` that could maybe be made to work but seem less important.
Each `ignore` has a rough "reason" for ignoring after it parentheses, with

- `(pseudo-rust)` meaning "mostly rust-like but contains foreign syntax"
- `(illustrative)` a somewhat catchall for either a fragment of rust that doesn't stand on its own (like a lone type), or abbreviated rust with ellipses and undeclared types that would get too cluttered if made compile-worthy.
- `(not-rust)` stuff that isn't rust but benefits from the syntax highlighting, like MIR.
- `(internal)` uses `rustc_*` code which would be difficult to make work with the testing setup.

Those reason notes are a bit inconsistently applied and messy though. If that's important I can go through them again and try a more principled approach. When I run `rg '```ignore \(' .` on the repo, there look to be lots of different conventions other people have used for this sort of thing. I could try unifying them all if that would be helpful.

I'm not sure if there was a better existing way to do this but I wrote my own script to help me run all the doctests and wade through the output. If that would be useful to anyone else, I put it here: https://github.com/Elliot-Roberts/rust_doctest_fixing_tool

compiler/rustc_mir_build/src/build/expr/as_operand.rs

@@ -42,15 +42,17 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// We tweak the handling of parameters of unsized type slightly to avoid the need to create a
     /// local variable of unsized type. For example, consider this program:
     ///
-    /// ```rust
-    /// fn foo(p: dyn Debug) { ... }
+    /// ```
+    /// #![feature(unsized_locals, unsized_fn_params)]
+    /// # use core::fmt::Debug;
+    /// fn foo(p: dyn Debug) { dbg!(p); }
     ///
-    /// fn bar(box_p: Box<dyn Debug>) { foo(*p); }
+    /// fn bar(box_p: Box<dyn Debug>) { foo(*box_p); }
     /// ```
     ///
     /// Ordinarily, for sized types, we would compile the call `foo(*p)` like so:
     ///
-    /// ```rust
+    /// ```ignore (illustrative)
     /// let tmp0 = *box_p; // tmp0 would be the operand returned by this function call
     /// foo(tmp0)
     /// ```
@@ -60,7 +62,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// that we create *stores the entire box*, and the parameter to the call itself will be
     /// `*tmp0`:
     ///
-    /// ```rust
+    /// ```ignore (illustrative)
     /// let tmp0 = box_p; call foo(*tmp0)
     /// ```
     ///