[ty] Fix attribute writes to unions/intersections including modules (#18313)

## Summary

Fix a bug that involved writes to attributes on union/intersection types
that included modules as elements.

This is a prerequisite to avoid some ecosystem false positives in
https://github.com/astral-sh/ruff/pull/18312

## Test Plan

Added regression test

crates/ty_python_semantic/resources/mdtest/attributes.md

@@ -1698,6 +1698,36 @@ reveal_type(outer.nested.inner.Outer.Nested.Inner.attr)  # revealed: int
 outer.nested.inner.Outer.Nested.Inner.attr = "a"
 ```
 
+### Unions of module attributes
+
+`mod1.py`:
+
+```py
+global_symbol: str = "a"
+```
+
+`mod2.py`:
+
+```py
+global_symbol: str = "a"
+```
+
+```py
+import mod1
+import mod2
+
+def _(flag: bool):
+    if flag:
+        mod = mod1
+    else:
+        mod = mod2
+
+    mod.global_symbol = "b"
+
+    # error: [invalid-assignment] "Object of type `Literal[1]` is not assignable to attribute `global_symbol` on type `<module 'mod1'> | <module 'mod2'>`"
+    mod.global_symbol = 1
+```
+
 ## Literal types
 
 ### Function-literal attributes

crates/ty_python_semantic/src/types/infer.rs

@@ -3406,24 +3406,31 @@ impl<'db> TypeInferenceBuilder<'db> {
             Type::ModuleLiteral(module) => {
                 if let Symbol::Type(attr_ty, _) = module.static_member(db, attribute) {
                     let assignable = value_ty.is_assignable_to(db, attr_ty);
-                    if !assignable {
+                    if assignable {
-                        report_invalid_attribute_assignment(
+                        true
-                            &self.context,
+                    } else {
-                            target.into(),
+                        if emit_diagnostics {
-                            attr_ty,
+                            report_invalid_attribute_assignment(
-                            value_ty,
+                                &self.context,
-                            attribute,
+                                target.into(),
-                        );
+                                attr_ty,
+                                value_ty,
+                                attribute,
+                            );
+                        }
+                        false
                     }
-
-                    false
                 } else {
-                    if let Some(builder) = self.context.report_lint(&UNRESOLVED_ATTRIBUTE, target) {
+                    if emit_diagnostics {
-                        builder.into_diagnostic(format_args!(
+                        if let Some(builder) =
-                            "Unresolved attribute `{}` on type `{}`.",
+                            self.context.report_lint(&UNRESOLVED_ATTRIBUTE, target)
-                            attribute,
+                        {
-                            object_ty.display(db)
+                            builder.into_diagnostic(format_args!(
-                        ));
+                                "Unresolved attribute `{}` on type `{}`.",
+                                attribute,
+                                object_ty.display(db)
+                            ));
+                        }
                     }
 
                     false