Exercise 3: Why Two Calls to makeCounter() Produce Independent Counters — Possible Solution
==================================================================================================

Each real call to makeCounter() runs the function's own body fresh,
from the top - including the line `var count = 0`, which creates a
genuinely new, independent count variable belonging to that specific
call's own execution. The closure returned at the end of that call
captures THIS particular count variable, not some single, shared
count that every call to makeCounter secretly refers to.

Because a closure captures a real REFERENCE to the specific variable
in its enclosing scope (not just a one-time snapshot of its value at
creation), that captured count variable stays alive for as long as the
closure holding a reference to it still exists - even though
makeCounter's own function body has already finished running and
would normally have its local variables cleaned up. This is exactly
what "capturing" means: the closure keeps its own captured variables
alive beyond the normal lifetime of the scope they were declared in.

So calling makeCounter() a second time creates an entirely separate,
new count variable, and a separate, new closure that captures THAT
specific variable - genuinely unconnected to the first call's own
count and closure. Calling the first counter repeatedly only ever
increments its own captured count; calling the second counter only
ever increments its own separate captured count. There's no real
shared state between them, because each call to makeCounter had its
own separate `var count = 0` line execute independently.

ANSWER: Each call to makeCounter() executes `var count = 0` fresh,
creating a genuinely new, independent count variable for that specific
call, and the closure returned by that call captures a reference to
THAT particular variable. Because closures keep their own captured
variables alive beyond the enclosing function's normal lifetime, each
returned closure maintains its own separate count - the two calls
never share state, since each one's count was created independently.

WHY THIS WORKS AS AN ANSWER
------------------------------
This correctly explains that each function call creates its own local
variable instance, and that closure capture ties a specific closure to
that specific instance rather than to a shared value, which is exactly
why the two counters stay independent of each other.