Challenge 3: Why Rust Doesn't Need Forward Declarations and C Does — Possible Solution
====================================================================

Per the chapter, C compiles TOP TO BOTTOM, in a single pass -- when the
compiler reaches a function call, it needs to already know that
function's signature (return type, parameter types) to correctly
generate code for the call, and if it hasn't yet encountered either a
declaration or the full definition earlier in the same translation
unit, it has no way to know that information yet. This reflects an
older, simpler compilation model: read the file once, left to right,
top to bottom, resolving each name as it's encountered, in the order
it appears.

Rust's compiler works differently: before generating any code, it
first performs a pass over the ENTIRE module to collect every
top-level item's signature -- functions, structs, and so on -- into a
symbol table, regardless of the order they're written in the source
file. Only after that whole-module collection step does it actually
type-check and compile function bodies. By the time any function call
is being compiled, the compiler already has a complete picture of
every function in the module, having read all of them once already,
so it can freely resolve a call to a function defined further down in
the same file without needing to have "seen" it yet in a strictly
linear sense.

What this reveals about each language's design: C's rule reflects a
genuinely simpler, more literal compilation model closely tied to how
the language was actually implemented in the 1970s -- process the file
once, in order, resolving as you go. Rust's whole-module-first approach
reflects a compiler built with more up-front analysis, treating a
module's contents as a complete, order-independent set of declarations
to be gathered before any code generation begins -- a more modern
compiler architecture that trades a bit more up-front work for a
genuinely more convenient rule for the programmer (define things in
whatever order makes the code most readable, not whatever order the
compiler happens to need).

WHY THIS WORKS AS AN ANSWER
------------------------------
This explains the actual COMPILER ARCHITECTURE difference (single
top-to-bottom pass vs. a whole-module collection pass before code
generation) rather than treating it as an arbitrary rule difference,
and connects that difference to each language's era and design
priorities.