Challenge 3: for (;;) as a Side Effect vs. Rust's Dedicated loop Keyword — Possible Solution
====================================================================

C's for (;;) achieves "loop forever" purely as a CONSEQUENCE of the
general for loop's syntax rules, not because C has any dedicated
concept of an infinite loop. A for loop's three parts (init; condition;
increment) are all OPTIONAL -- omitting the condition specifically
means there's simply nothing to evaluate as false, so the loop never
has a reason to stop on its own. "Infinite loop" isn't a distinct
feature C's designers built in; it emerges as an edge case of a more
general, three-part construct that happens to allow empty parts.
while (1) is the same idea from a different angle -- 1 is always
nonzero, so the condition is always true, using the language's general
truthiness rule (Chapter 3) rather than any infinite-loop-specific
mechanism.

Rust's loop keyword, by contrast, is a DEDICATED construct that exists
specifically and only to mean "run forever until an explicit break."
It isn't a degenerate case of some other more general loop form --
Rust's designers looked at the common intent "loop indefinitely" and
gave it its own first-class keyword, rather than requiring it to be
expressed as a special-case invocation of `while` or `for`.

What this difference reflects about each language's design philosophy:
C, as a much older language, tends to reuse a small number of general
constructs and let specific behaviors fall out of their general rules
(an empty condition just happens to mean "always true") -- consistent
with the "manual control, minimal built-in guidance" character this
course keeps returning to. Rust, designed decades later with the
benefit of hindsight about what programmers actually write often
enough to deserve dedicated, explicit syntax, prefers naming common
intents directly rather than leaving them as emergent behavior of a
more general rule.

WHY THIS WORKS AS AN ANSWER
------------------------------
This distinguishes "infinite loop as an emergent edge case of a general
construct" (C) from "infinite loop as a deliberately named, dedicated
construct" (Rust), and connects that specific difference to each
language's broader design philosophy rather than treating it as a
superficial syntax difference.