Challenge 3: Why the Diamond Problem Cannot Occur in Rust — Possible Solution
====================================================================

The diamond problem in C++ arises specifically because CLASS
INHERITANCE copies DATA -- when Swimmer inherits from Animal, Swimmer
literally contains its own embedded Animal sub-object, including
Animal's actual data fields (like name). If two different paths (via
Swimmer and via Flyer) both independently inherit from the same base,
each path brings along its OWN separate copy of that base's data --
the ambiguity is a direct, structural consequence of DATA being
duplicated along each inheritance path.

Rust's trait system is structurally incapable of creating this
situation, because a trait NEVER carries data belonging to the type
that implements it. A trait declares a set of METHOD SIGNATURES (and
optionally default method bodies) -- it has no fields of its own, and
implementing a trait for a struct never adds or duplicates any of the
struct's own fields. When a struct implements multiple traits (Rust's
equivalent of "inheriting from multiple sources"), it is still exactly
ONE struct, with exactly the fields IT ITSELF declared, all in one
place -- there is no possibility of two different trait implementations
each bringing along their own separate copy of some shared base's
data, because traits never had any data to bring along in the first
place.

In other words: C++'s multiple inheritance mixes together two
genuinely different concerns -- inheriting DATA and inheriting
BEHAVIOR -- through the same mechanism, which is exactly what makes the
diamond problem possible when data is inherited along two paths. Rust
splits these two concerns apart entirely: a struct's data lives in
exactly one place (the struct's own definition, never inherited from
anywhere), while traits provide ONLY behavior, with no data attached at
all -- removing the specific ingredient (duplicated inherited data)
the diamond problem requires to exist.

WHY THIS WORKS AS AN ANSWER
------------------------------
This identifies the SPECIFIC structural difference (C++ inheritance
duplicates data along each path; Rust traits carry no data at all) that
makes the diamond problem possible in one language and structurally
impossible in the other, rather than a vague "Rust is different,"
explaining precisely which ingredient Rust's design removes.