Add example of reversed pointer bytes being rejected

Let's add an example demonstrating that reversing the order of pointer
bytes causes compilation to fail, even though all bytes are present.
The compiler tracks the position of each byte within its original
pointer and only accepts pointers when reassembled in the correct
order.

This example copies a pointer byte-by-byte in reverse order into the
padding of a struct, which fails because the fragment indices don't
match up to form a valid pointer.

Context:

- rust-lang/rust#144081

Author: traviscross

src/const_eval.md

@@ -264,6 +264,28 @@ const C: Pair = unsafe {
 > The bytes with provenance must form a complete pointer in the correct order. In the example above, the pointer is written at offset 20, but a pointer requires 8 bytes (assuming an 8-byte pointer). Four of those bytes fit in the `y` field; the rest extend into the padding at offset 24. When the fields are initialized, the `y` bytes get overwritten, leaving only a partial pointer (4 bytes) in the padding. These 4 bytes have provenance but don't form a complete pointer, causing compilation to fail.
 >
 > This restriction ensures that any bytes with provenance in the final value represent complete pointers. Binary formats such as ELF cannot represent pointer fragments, so the compiler cannot emit them in the final binary.
+>
+> Reversing the order of the pointer bytes also causes compilation to fail, even though all bytes are present:
+>
+> ```rust,compile_fail
+> # use core::mem::{self, MaybeUninit};
+> const PTR_WIDTH: usize = mem::size_of::<*const u8>();
+> const _: MaybeUninit<u64> = unsafe {
+> //       ^^^^^^^^^^^^^^^^
+> //       ERROR: Partial pointer in final value of constant.
+>     let mut m = MaybeUninit::<u64>::uninit();
+>     let ptr: *const u8 = &0;
+>     let ptr_bytes = &raw const ptr as *const MaybeUninit<u8>;
+>     // Write pointer bytes in reverse order.
+>     let dst: *mut MaybeUninit<u8> = m.as_mut_ptr().cast();
+>     let mut i = 0;
+>     while i < PTR_WIDTH {
+>         dst.add(i).write(ptr_bytes.add(PTR_WIDTH - 1 - i).read());
+>         i += 1;
+>     }
+>     m
+> };
+> ```
 
 > [!NOTE]
 > Manually initializing (e.g., zeroing) the padding bytes ensures the final value is accepted: