[red-knot] Add support for unpacking for target (#15058)

## Summary

Related to #13773 

This PR adds support for unpacking `for` statement targets.

This involves updating the `value` field in the `Unpack` target to use
an enum which specifies the "where did the value expression came from?".
This is because for an iterable expression, we need to unpack the
iterator type while for assignment statement we need to unpack the value
type itself. And, this needs to be done in the unpack query.

### Question

One of the ways unpacking works in `for` statement is by looking at the
union of the types because if the iterable expression is a tuple then
the iterator type will be union of all the types in the tuple. This
means that the test cases that will test the unpacking in `for`
statement will also implicitly test the unpacking union logic. I was
wondering if it makes sense to merge these cases and only add the ones
that are specific to the union unpacking or for statement unpacking
logic.

## Test Plan

Add test cases involving iterating over a tuple type. I've intentionally
left out certain cases for now and I'm curious to know any thoughts on
the above query.

crates/red_knot_python_semantic/src/unpack.rs

@@ -1,7 +1,9 @@
 use ruff_db::files::File;
-use ruff_python_ast::{self as ast};
+use ruff_python_ast::{self as ast, AnyNodeRef};
+use ruff_text_size::{Ranged, TextRange};
 
 use crate::ast_node_ref::AstNodeRef;
+use crate::semantic_index::ast_ids::{HasScopedExpressionId, ScopedExpressionId};
 use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::{FileScopeId, ScopeId};
 use crate::Db;
@@ -41,7 +43,7 @@ pub(crate) struct Unpack<'db> {
     /// The ingredient representing the value expression of the unpacking. For example, in
     /// `(a, b) = (1, 2)`, the value expression is `(1, 2)`.
     #[no_eq]
-    pub(crate) value: Expression<'db>,
+    pub(crate) value: UnpackValue<'db>,
 
     #[no_eq]
     count: countme::Count<Unpack<'static>>,
@@ -52,4 +54,48 @@ impl<'db> Unpack<'db> {
     pub(crate) fn scope(self, db: &'db dyn Db) -> ScopeId<'db> {
         self.file_scope(db).to_scope_id(db, self.file(db))
     }
+
+    /// Returns the range of the unpack target expression.
+    pub(crate) fn range(self, db: &'db dyn Db) -> TextRange {
+        self.target(db).range()
+    }
+}
+
+/// The expression that is being unpacked.
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum UnpackValue<'db> {
+    /// An iterable expression like the one in a `for` loop or a comprehension.
+    Iterable(Expression<'db>),
+    /// An expression that is being assigned to a target.
+    Assign(Expression<'db>),
+}
+
+impl<'db> UnpackValue<'db> {
+    /// Returns `true` if the value is an iterable expression.
+    pub(crate) const fn is_iterable(self) -> bool {
+        matches!(self, UnpackValue::Iterable(_))
+    }
+
+    /// Returns the underlying [`Expression`] that is being unpacked.
+    pub(crate) const fn expression(self) -> Expression<'db> {
+        match self {
+            UnpackValue::Assign(expr) | UnpackValue::Iterable(expr) => expr,
+        }
+    }
+
+    /// Returns the [`ScopedExpressionId`] of the underlying expression.
+    pub(crate) fn scoped_expression_id(
+        self,
+        db: &'db dyn Db,
+        scope: ScopeId<'db>,
+    ) -> ScopedExpressionId {
+        self.expression()
+            .node_ref(db)
+            .scoped_expression_id(db, scope)
+    }
+
+    /// Returns the expression as an [`AnyNodeRef`].
+    pub(crate) fn as_any_node_ref(self, db: &'db dyn Db) -> AnyNodeRef<'db> {
+        self.expression().node_ref(db).node().into()
+    }
 }