[red-knot] Add initial support for * imports (#16923)

## Summary

This PR adds initial support for `*` imports to red-knot. The approach
is to implement a standalone query, called from semantic indexing, that
visits the module referenced by the `*` import and collects all
global-scope public names that will be imported by the `*` import. The
`SemanticIndexBuilder` then adds separate definitions for each of these
names, all keyed to the same `ast::Alias` node that represents the `*`
import.

There are many pieces of `*`-import semantics that are still yet to be
done, even with this PR:
- This PR does not attempt to implement any of the semantics to do with
`__all__`. (If a module defines `__all__`, then only the symbols
included in `__all__` are imported, _not_ all public global-scope
symbols.
- With the logic implemented in this PR as it currently stands, we
sometimes incorrectly consider a symbol bound even though it is defined
in a branch that is statically known to be dead code, e.g. (assuming the
target Python version is set to 3.11):

  ```py
  # a.py

  import sys

  if sys.version_info < (3, 10):
      class Foo: ...

  ```

  ```py
  # b.py

  from a import *

  print(Foo)  # this is unbound at runtime on 3.11,
# but we currently consider it bound with the logic in this PR
  ```

Implementing these features is important, but is for now deferred to
followup PRs.

Many thanks to @ntBre, who contributed to this PR in a pairing session
on Friday!

## Test Plan

Assertions in existing mdtests are adjusted, and several new ones are
added.

crates/red_knot_python_semantic/src/module_name.rs

@@ -1,10 +1,15 @@
 use std::fmt;
+use std::num::NonZeroU32;
 use std::ops::Deref;
 
 use compact_str::{CompactString, ToCompactString};
 
+use ruff_db::files::File;
+use ruff_python_ast as ast;
 use ruff_python_stdlib::identifiers::is_identifier;
 
+use crate::{db::Db, module_resolver::file_to_module};
+
 /// A module name, e.g. `foo.bar`.
 ///
 /// Always normalized to the absolute form (never a relative module name, i.e., never `.foo`).
@@ -206,6 +211,29 @@ impl ModuleName {
     pub fn ancestors(&self) -> impl Iterator<Item = Self> {
         std::iter::successors(Some(self.clone()), Self::parent)
     }
+
+    pub(crate) fn from_import_statement<'db>(
+        db: &'db dyn Db,
+        importing_file: File,
+        node: &'db ast::StmtImportFrom,
+    ) -> Result<Self, ModuleNameResolutionError> {
+        let ast::StmtImportFrom {
+            module,
+            level,
+            names: _,
+            range: _,
+        } = node;
+
+        let module = module.as_deref();
+
+        if let Some(level) = NonZeroU32::new(*level) {
+            relative_module_name(db, importing_file, module, level)
+        } else {
+            module
+                .and_then(Self::new)
+                .ok_or(ModuleNameResolutionError::InvalidSyntax)
+        }
+    }
 }
 
 impl Deref for ModuleName {
@@ -234,3 +262,58 @@ impl std::fmt::Display for ModuleName {
         f.write_str(&self.0)
     }
 }
+
+/// Given a `from .foo import bar` relative import, resolve the relative module
+/// we're importing `bar` from into an absolute [`ModuleName`]
+/// using the name of the module we're currently analyzing.
+///
+/// - `level` is the number of dots at the beginning of the relative module name:
+///   - `from .foo.bar import baz` => `level == 1`
+///   - `from ...foo.bar import baz` => `level == 3`
+/// - `tail` is the relative module name stripped of all leading dots:
+///   - `from .foo import bar` => `tail == "foo"`
+///   - `from ..foo.bar import baz` => `tail == "foo.bar"`
+fn relative_module_name(
+    db: &dyn Db,
+    importing_file: File,
+    tail: Option<&str>,
+    level: NonZeroU32,
+) -> Result<ModuleName, ModuleNameResolutionError> {
+    let module = file_to_module(db, importing_file)
+        .ok_or(ModuleNameResolutionError::UnknownCurrentModule)?;
+    let mut level = level.get();
+
+    if module.kind().is_package() {
+        level = level.saturating_sub(1);
+    }
+
+    let mut module_name = module
+        .name()
+        .ancestors()
+        .nth(level as usize)
+        .ok_or(ModuleNameResolutionError::TooManyDots)?;
+
+    if let Some(tail) = tail {
+        let tail = ModuleName::new(tail).ok_or(ModuleNameResolutionError::InvalidSyntax)?;
+        module_name.extend(&tail);
+    }
+
+    Ok(module_name)
+}
+
+/// Various ways in which resolving a [`ModuleName`]
+/// from an [`ast::StmtImport`] or [`ast::StmtImportFrom`] node might fail
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub(crate) enum ModuleNameResolutionError {
+    /// The import statement has invalid syntax
+    InvalidSyntax,
+
+    /// We couldn't resolve the file we're currently analyzing back to a module
+    /// (Only necessary for relative import statements)
+    UnknownCurrentModule,
+
+    /// The relative import statement seems to take us outside of the module search path
+    /// (e.g. our current module is `foo.bar`, and the relative import statement in `foo.bar`
+    /// is `from ....baz import spam`)
+    TooManyDots,
+}