Challenge 3: What Monomorphization Actually Means, and Why Two Separate Functions Result — Possible Solution
====================================================================

Monomorphization is the compilation strategy where the compiler, upon
encountering a call to a template with a SPECIFIC concrete type,
generates a genuinely separate, fully concrete (non-generic) copy of
that function or class -- specialized entirely for that one type -- as
part of compilation, BEFORE the program ever runs. The template itself
is never compiled into any kind of "generic" runtime code capable of
handling arbitrary types on the fly; it exists purely as a BLUEPRINT
the compiler uses to stamp out one real, ordinary function per distinct
type actually requested somewhere in the program.

Why calling max_value with both int and double arguments results in
genuinely TWO separate compiled functions, not one function handling
both cases at runtime: when the compiler processes `max_value(3, 7)`,
it sees the template being requested with T = int, and generates a
complete, ordinary function -- effectively identical to if a programmer
had hand-written `int max_value(int a, int b) { return (a > b) ? a :
b; }` directly -- fully type-checked and compiled specifically for int.
Separately, when it processes `max_value(2.5, 1.1)`, it sees T = double
requested, and generates ANOTHER complete, ordinary function,
effectively `double max_value(double a, double b) { ... }`, fully
type-checked and compiled specifically for double. These are two
entirely distinct pieces of compiled machine code, each with its own
address, each doing exactly one job -- there is no single shared
function containing a runtime type-check or dispatch logic deciding
"if int, do this; if double, do that." Every type-related decision was
already fully resolved by the compiler, at compile time, before the
program ever executes -- which is precisely why calling the resulting
functions carries zero runtime overhead compared to functions that had
simply been hand-written separately for each type from the start.

WHY THIS WORKS AS AN ANSWER
------------------------------
This defines monomorphization as generating separate, concrete,
compile-time-resolved copies (not vague "compiler magic"), and directly
explains WHY this produces two genuinely distinct compiled functions
rather than one runtime-dispatched function -- tying the explanation to
the chapter's own zero-runtime-overhead claim as a direct consequence
of the mechanism, not a separate, unrelated fact.