Remove restriction on dereferencing pointers in const

We had said that the dereference operator could not be used with raw
pointers in a constant expression.  However, that restriction has been
lifted.  First, in Rust 1.58, we stabilized `const_raw_ptr_deref`.

rust-lang/rust#89551

This allowed for dereferencing immutable raw pointers in a constant
expression.  Then, in Rust 1.83, we stabilized `const_mut_refs` and
`const_refs_to_cell`.

rust-lang/rust#129195

That allowed for:

- Mentioning `&mut` types.
- Creating `&mut` and `*mut` values.
- Creating `&T` and `*const T` values where `T` contains interior
  mutability.
- Dereferencing `&mut` and `*mut` values (both for reads and writes).

Let's remove the stated restriction on dereferencing raw pointers in a
constant expression and add examples.

Author: traviscross

src/const_eval.md

@@ -203,7 +203,23 @@ r[const-eval.const-expr.borrows]
   > See [issue #143129](https://github.com/rust-lang/rust/issues/143129) for more details.
 
 r[const-eval.const-expr.deref]
-* The [dereference operator] except for raw pointers.
+* The [dereference operator].
+
+  ```rust,no_run
+  # use core::cell::UnsafeCell;
+  const _: u8 = unsafe {
+      let x: *mut u8 = &raw mut *&mut 0;
+      //                          ^^^^^^^
+      //             Dereference of mutable reference.
+      *x = 1; // Dereference of mutable pointer.
+      *(x as *const u8) // Dereference of constant pointer.
+  };
+  const _: u8 = unsafe {
+      let x = &UnsafeCell::new(0);
+      *x.get() = 1; // Mutation of interior mutable value.
+      *x.get()
+  };
+  ```
 
 r[const-eval.const-expr.group]