Set dunder operators too permissive?

Similar to #1840

With #3181 I made KeysView consistent with Set but I really think the operators are confusingly permissive.

Let's look at them

# difference
{'1'} - {2}
reveal_type({'1'} - {2})  # => Set[str]

This should fail because this is always a null operation and thus
a programmer error.

# intersection
{'1'} & {2}  # => Set[str]
reveal_type({'1'} & {2})  # => Set[str]

This really should fail because it is unlikely meaningful; the
return type is always an empty set thus it is also not a Set[str]

# sym difference
{'1'} ^ {2}
reveal_type({'1'} ^ {2})  # => Set[Union[str, int]]

Although the assumed union type is correct, Set[A] & Set[B] => Set[A|B] just doesn't make sense. The operator can only meaningful be applied to same type sets. What we do here is just a form of plain concat or union.

# union
{'1'} | {2} # MAYBE OK
reveal_type({'1'} | {2})  # => Set[Union[str, int]]

If we look at Sets as just containers without some
properties, we could accept it to construct mixed
type Sets using 'union'. I think it is okay for Python,
the name union makes it meaningful, but I maybe never did
that in practice.
Since it adds to the type it is also likely that
the following part of the program catches mistakes.

(But lists don't allow that [1] + ['2'] although they're really
arbitrary containers. Except my PR #3183.)

Comienza con los ejemplos de este issue y compara las discusiones relacionadas en #1840, #3181 y #3183. Determina qué operadores de Set y KeysView deberían rechazar tipos de elementos mixtos, incluido si union debe seguir estando permitido. El trabajo estará terminado cuando el proyecto tenga una regla acordada para cada operador y el comportamiento de typing relevante refleje esa decisión.