Fix F811 false positive for overloaded functions from typing-modules (#23357)

## Summary

Fixes #19632.

When `@overload` is imported from a custom module listed in
`typing-modules` (e.g., `from std import overload`), Ruff fails to
recognize it as the `typing.overload` decorator and emits false F811
diagnostics for each overloaded function definition.

The root cause is in `SemanticModel::match_typing_qualified_name`:
`QualifiedName::from_dotted_name` splits on dots, so a single-segment
module like `std` still works, but the internal representation stores it
differently from what `QualifiedName::user_defined` produces. Use
`user_defined` instead to match the internal representation
consistently.

## Test plan

- Reproduction case: `ruff check --select F811 --config ruff.toml
temp.py` no longer emits false positives for `@overload` from custom
typing-modules
- `cargo test -p ruff_linter -- pyflakes` — all 462 tests pass

---------

Co-authored-by: Brent Westbrook <brentrwestbrook@gmail.com>

Author: kar-ganap

crates/ruff_linter/resources/test/fixtures/pyflakes/F811_33.py

@@ -0,0 +1,19 @@
+# Regression test for https://github.com/astral-sh/ruff/issues/19632
+# When @overload is imported from a custom module listed in typing-modules,
+# Ruff should recognize it as typing.overload and not emit false F811
+# diagnostics for each overloaded function definition.
+#
+# Requires: typing-modules = ["std"]
+from std import overload
+
+
+@overload
+def func(a: str, b: int) -> int: ...
+
+
+@overload
+def func(a: int, b: str) -> int: ...
+
+
+def func(a: int | str, b: int | str) -> int:
+    return 0

crates/ruff_linter/src/rules/pyflakes/mod.rs

@@ -708,6 +708,19 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn f811_typing_modules_overload() -> Result<()> {
+        let diagnostics = test_path(
+            Path::new("pyflakes/F811_33.py"),
+            &LinterSettings {
+                typing_modules: vec!["std".to_string()],
+                ..LinterSettings::for_rule(Rule::RedefinedWhileUnused)
+            },
+        )?;
+        assert_diagnostics!(diagnostics);
+        Ok(())
+    }
+
     #[test]
     fn extend_generics() -> Result<()> {
         let snapshot = "extend_immutable_calls".to_string();

crates/ruff_linter/src/rules/pyflakes/snapshots/ruff_linter__rules__pyflakes__tests__f811_typing_modules_overload.snap

@@ -0,0 +1,4 @@
+---
+source: crates/ruff_linter/src/rules/pyflakes/mod.rs
+---
+

crates/ruff_python_semantic/src/model.rs

@@ -209,7 +209,7 @@ impl<'a> SemanticModel<'a> {
         }
 
         if self.typing_modules.iter().any(|module| {
-            let module = QualifiedName::from_dotted_name(module);
+            let module = QualifiedName::user_defined(module);
             qualified_name == &module.append_member(target)
         }) {
             return true;