Challenge 3: Tracing the Zero-Cost Thread Across All Three Courses — Possible Solution
====================================================================

COURSE 1 EXAMPLE: Ownership and borrowing (Chapters 3-4). By verifying
at COMPILE TIME that exactly one owner exists for any given piece of
data and that references never outlive the data they point to, Rust
avoids paying for a garbage collector's runtime cost — no background
process scans memory or introduces pause times while the program is
actually running, because the compiler has already proven the memory
is safe to manage deterministically before the program starts.

COURSE 2 EXAMPLE: Monomorphized generics (Chapter 3). By generating a
completely separate, fully concrete version of a generic function or
struct for every distinct type it's actually used with, Rust avoids
paying for any RUNTIME dispatch cost (no vtable lookup, no boxing) when
using generic code — a call into a monomorphized generic function
executes as plain, ordinary, type-specific machine code, exactly as if
it had been hand-written separately for that one type.

COURSE 3 (THIS CHAPTER'S OWN AREA) EXAMPLE: Iterators (originally
covered in Course 1 Chapter 8, revisited here). By compiling an
iterator chain (like .filter().map().collect()) down to a single tight
loop at compile time, Rust avoids paying for the overhead a naively
implemented iterator abstraction might otherwise introduce — no extra
allocation or function-call overhead purely for the "abstraction" of
chaining operations together, beyond whatever the equivalent
hand-written loop would already cost.

THE COMMON THREAD: in every case, the SAFETY OR CONVENIENCE benefit
(no manual memory management footguns, reusable generic code, readable
chained iterator syntax) is achieved through work the COMPILER does
once, ahead of time, rather than work a RUNTIME system would otherwise
need to repeat continuously while the program executes — which is
precisely the mechanism behind "zero-cost abstraction" as this chapter
defined it.