[red-knot] Remove Type::Unbound (#13980)

<!--
Thank you for contributing to Ruff! To help us out with reviewing,
please consider the following:

- Does this pull request include a summary of the change? (See below.)
- Does this pull request include a descriptive title?
- Does this pull request include references to any relevant issues?
-->

## Summary

- Remove `Type::Unbound`
- Handle (potential) unboundness as a concept orthogonal to the type
system (see new `Symbol` type)
- Improve existing and add new diagnostics related to (potential)
unboundness

closes #13671 

## Test Plan

- Update existing markdown-based tests
- Add new tests for added/modified functionality

crates/red_knot_python_semantic/src/stdlib.rs

@@ -2,7 +2,8 @@ use crate::module_name::ModuleName;
 use crate::module_resolver::resolve_module;
 use crate::semantic_index::global_scope;
 use crate::semantic_index::symbol::ScopeId;
-use crate::types::{global_symbol_ty, Type};
+use crate::symbol::Symbol;
+use crate::types::global_symbol;
 use crate::Db;
 
 /// Enumeration of various core stdlib modules, for which we have dedicated Salsa queries.
@@ -33,62 +34,55 @@ impl CoreStdlibModule {
 
 /// Lookup the type of `symbol` in a given core module
 ///
-/// Returns `Unbound` if the given core module cannot be resolved for some reason
-fn core_module_symbol_ty<'db>(
+/// Returns `Symbol::Unbound` if the given core module cannot be resolved for some reason
+fn core_module_symbol<'db>(
     db: &'db dyn Db,
     core_module: CoreStdlibModule,
     symbol: &str,
-) -> Type<'db> {
+) -> Symbol<'db> {
     resolve_module(db, &core_module.name())
-        .map(|module| global_symbol_ty(db, module.file(), symbol))
-        .map(|ty| {
-            if ty.is_unbound() {
-                ty
-            } else {
-                ty.replace_unbound_with(db, Type::Never)
-            }
-        })
-        .unwrap_or(Type::Unbound)
+        .map(|module| global_symbol(db, module.file(), symbol))
+        .unwrap_or(Symbol::Unbound)
 }
 
 /// Lookup the type of `symbol` in the builtins namespace.
 ///
-/// Returns `Unbound` if the `builtins` module isn't available for some reason.
+/// Returns `Symbol::Unbound` if the `builtins` module isn't available for some reason.
 #[inline]
-pub(crate) fn builtins_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db> {
-    core_module_symbol_ty(db, CoreStdlibModule::Builtins, symbol)
+pub(crate) fn builtins_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db> {
+    core_module_symbol(db, CoreStdlibModule::Builtins, symbol)
 }
 
 /// Lookup the type of `symbol` in the `types` module namespace.
 ///
-/// Returns `Unbound` if the `types` module isn't available for some reason.
+/// Returns `Symbol::Unbound` if the `types` module isn't available for some reason.
 #[inline]
-pub(crate) fn types_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db> {
-    core_module_symbol_ty(db, CoreStdlibModule::Types, symbol)
+pub(crate) fn types_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db> {
+    core_module_symbol(db, CoreStdlibModule::Types, symbol)
 }
 
 /// Lookup the type of `symbol` in the `typing` module namespace.
 ///
-/// Returns `Unbound` if the `typing` module isn't available for some reason.
+/// Returns `Symbol::Unbound` if the `typing` module isn't available for some reason.
 #[inline]
 #[allow(dead_code)] // currently only used in tests
-pub(crate) fn typing_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db> {
-    core_module_symbol_ty(db, CoreStdlibModule::Typing, symbol)
+pub(crate) fn typing_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db> {
+    core_module_symbol(db, CoreStdlibModule::Typing, symbol)
 }
 /// Lookup the type of `symbol` in the `_typeshed` module namespace.
 ///
-/// Returns `Unbound` if the `_typeshed` module isn't available for some reason.
+/// Returns `Symbol::Unbound` if the `_typeshed` module isn't available for some reason.
 #[inline]
-pub(crate) fn typeshed_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db> {
-    core_module_symbol_ty(db, CoreStdlibModule::Typeshed, symbol)
+pub(crate) fn typeshed_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db> {
+    core_module_symbol(db, CoreStdlibModule::Typeshed, symbol)
 }
 
 /// Lookup the type of `symbol` in the `typing_extensions` module namespace.
 ///
-/// Returns `Unbound` if the `typing_extensions` module isn't available for some reason.
+/// Returns `Symbol::Unbound` if the `typing_extensions` module isn't available for some reason.
 #[inline]
-pub(crate) fn typing_extensions_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db> {
-    core_module_symbol_ty(db, CoreStdlibModule::TypingExtensions, symbol)
+pub(crate) fn typing_extensions_symbol<'db>(db: &'db dyn Db, symbol: &str) -> Symbol<'db> {
+    core_module_symbol(db, CoreStdlibModule::TypingExtensions, symbol)
 }
 
 /// Get the scope of a core stdlib module.