Homeless Structs idea is a bit similar to "Anonymous" Structs and "Unnamed" Structs. With only one difference - they are neither anonymous not unnamed, because these Structs have names!
I think you might be misjudging the purpose of the orphan rules. Ordinary structs (or enums) having a specific crate that defines them – a “home” if you will to use your terminology here – is not a burden but a power. Orphan rules don’t exist to protect the “implementation rights” of some “definer” and “owner” of a struct, no:[1] Orphan rules exist to ensure proper coherence, two independent crates shall not be able to write (conflicting versions of) the same implementation of a trait for a type, without knowing of each other (i.e. one depending on the other)!
For the simple reason that writing an implementation for a trait means you need to depend on the defining crates of the trait and type(s) in question, those crates can gain the power to write trait implementation without any risk of coherence issues. For your “homeless” structs, no crate could hold the powers of the defining crate of the struct – consequently, it would be not okay to write trait implementations anywhere (except perhaps the crate that defines the trait in question).
Ok, but tuples are also homeless structs with a well known name ((i32, u32) could be called, under this scheme, Tuple2 :{0: i32, 1: u32)). You can still impl traits for tuples.
Could the same rule that enables writing impl MyTrait for (i32, u32) be used to impl traits for homeless structs?
But what's needed to make this practical is a way to impl a trait for all homeless structs, whenever appropriate; that is, a way to be generic on the homeless struct name (which means that the stdlib could add some common traits). I mean it would be very awkward if those structs couldn't impl Default and such.
No, tuples are treated as foreign types always (essentially their defining crate is “the compiler”). They obey the orphan rules to determine when you are allowed to implement traits for them.
This is not "avoid orphan rule". This is "get rid of orphan rule". While orphan rule has pros and cons and whether a new programming language should have orphan rule is an interesting question, I don't think it is an appropriate question for Rust at this time.
I think a more interesting way for side stepping the orphan rule would be to explicitly allow it with an annotation like #[allow(orphan_implementation)]. I can see two uses for it:
Allowing crates do implement a trait defined in another crate, without forcing a dependency (e.g. tokio and futures).
Allowing application code to side step the rule. Since there are no dependants for the crate, no downstream crates can be broken from liberally bypassing the rule.