Challenge 3: Why RAII and Drop Are the Same Idea, and the One Mechanical Difference — Possible Solution
====================================================================

RAII and Rust's Drop trait are the same underlying idea because both
express the identical core principle the chapter names directly: tie a
resource's release to an OBJECT'S LIFETIME, so that cleanup happens
automatically the moment the object's scope ends, on every exit path
-- normal return, early return, or an error/exception unwinding through
the stack -- with no possibility of the programmer forgetting to write
the release code at each individual usage site. In both languages, the
programmer writes the cleanup logic exactly ONCE (in a destructor or in
a Drop implementation), and the language's own runtime behavior
guarantees it executes automatically every time an instance's lifetime
ends, rather than needing to be called explicitly at every point of
use the way c2-2's free() had to be.

The one concrete mechanical difference in how each language actually
TRIGGERS the cleanup code: in C++, the compiler inserts a call to the
object's destructor (~ClassName()) directly at the specific point in
the generated machine code where the object's scope ends -- this is
essentially a compile-time-determined, syntactically-driven insertion
tied to lexical scope boundaries (the closing brace). In Rust, the
mechanism is formally the Drop trait's own drop() method, invoked by
the compiler's ownership-tracking system specifically at the point
where a value's LAST OWNER goes out of scope -- which is determined not
just by lexical scope but by Rust's own move/ownership analysis (a
value moved elsewhere is no longer dropped at its original scope's
end, since ownership transferred away first). C++'s destructor timing
is driven purely by scope; Rust's Drop timing is driven by ownership
tracking, which can diverge from simple lexical scope when a value is
moved.

WHY THIS WORKS AS AN ANSWER
------------------------------
This identifies the shared core principle precisely (tie cleanup to
object lifetime, guaranteed on every exit path, written once) rather
than a vague "they're similar," and names a genuine, specific mechanical
difference (scope-triggered destructor calls in C++ vs.
ownership-tracking-triggered Drop calls in Rust) rather than claiming
the two mechanisms are identical in every respect.