Challenge 1: Modifying a Value Through a Raw Pointer — Possible Solution
====================================================================

fn main() {
    let mut x = 5;
    let r = &mut x as *mut i32;

    unsafe {
        *r += 10;
    }

    println!("{}", x); // 15
}

WHY THIS WORKS AS AN ANSWER
------------------------------
&mut x as *mut i32 CREATES a mutable raw pointer from an existing
mutable reference — per this chapter's explanation, creating a raw
pointer itself is safe and requires no unsafe block, even though it's
a mutable pointer.

*r += 10 is where DEREFERENCING actually happens — reading through the
pointer to get the current value AND writing a new value back through
it — and this is exactly the operation this chapter identified as one
of the five things unsafe specifically unlocks. Wrapping it in an
unsafe block is required precisely because the compiler can no longer
verify, on its own, that r still points at valid, exclusively-accessed
memory at the moment of dereferencing — the programmer (here,
correctly) is vouching for that instead.

Printing x afterward, OUTSIDE the unsafe block and using the original
variable directly (not the pointer), confirms the mutation through r
genuinely affected the same underlying memory x itself occupies — x
prints 15, not the original 5, proving the raw pointer wasn't just a
separate, disconnected copy of the value.