[red-knot] Port type inference tests to new test framework (#13719)

## Summary

Porting infer tests to new markdown tests framework.

Link to the corresponding issue: #13696

---------

Co-authored-by: Carl Meyer <carl@astral.sh>

crates/red_knot_python_semantic/resources/mdtest/subscript/bytes.md

@@ -0,0 +1,15 @@
+# Bytes subscript
+
+## Simple
+
+```py
+w = b'red' b'knot'
+x = b'hello'
+y = b'world' + b'!'
+z = b'\xff\x00'
+
+reveal_type(w)  # revealed: Literal[b"redknot"]
+reveal_type(x)  # revealed: Literal[b"hello"]
+reveal_type(y)  # revealed: Literal[b"world!"]
+reveal_type(z)  # revealed: Literal[b"\xff\x00"]
+```

crates/red_knot_python_semantic/resources/mdtest/subscript/class.md

@@ -0,0 +1,92 @@
+# Class subscript
+
+## Class getitem unbound
+
+```py
+class NotSubscriptable: pass
+a = NotSubscriptable[0]  # error: "Cannot subscript object of type `Literal[NotSubscriptable]` with no `__class_getitem__` method"
+```
+
+## Class getitem
+
+```py
+class Identity:
+    def __class_getitem__(cls, item: int) -> str:
+        return item
+
+a = Identity[0]  
+reveal_type(a) # revealed: str
+```
+
+## Class getitem union
+
+```py
+flag = True
+
+class Identity:
+    if flag:
+        def __class_getitem__(cls, item: int) -> str:
+            return item
+    else:
+        def __class_getitem__(cls, item: int) -> int:
+            return item
+
+a = Identity[0]  
+reveal_type(a) # revealed: str | int
+```
+
+## Class getitem with class union
+
+```py
+flag = True
+
+class Identity1:
+    def __class_getitem__(cls, item: int) -> str:
+        return item
+
+class Identity2:
+    def __class_getitem__(cls, item: int) -> int:
+        return item
+
+if flag:
+    a = Identity1
+else:
+    a = Identity2
+
+b = a[0]
+reveal_type(a) # revealed: Literal[Identity1, Identity2]
+reveal_type(b) # revealed: str | int
+```
+
+## Class getitem with unbound method union
+
+```py
+flag = True
+
+if flag:
+    class Identity:
+        def __class_getitem__(self, x: int) -> str:
+            pass
+else:
+    class Identity: pass
+
+a = Identity[42] # error: [call-non-callable] "Method `__class_getitem__` of type `Literal[__class_getitem__] | Unbound` is not callable on object of type `Literal[Identity, Identity]`" 
+reveal_type(a) # revealed: str | Unknown 
+```
+
+## TODO: Class getitem non-class union
+
+```py
+flag = True
+
+if flag:
+    class Identity:
+        def __class_getitem__(self, x: int) -> str:
+            pass
+else:
+    Identity = 1
+
+a = Identity[42] # error: "Cannot subscript object of type `Literal[Identity] | Literal[1]` with no `__getitem__` method"
+# TODO: should _probably_ emit `str | Unknown` 
+reveal_type(a) # revealed: Unknown 
+```

crates/red_knot_python_semantic/resources/mdtest/subscript/instance.md

@@ -0,0 +1,45 @@
+# Instance subscript
+
+## Getitem unbound
+
+```py
+class NotSubscriptable: pass
+a = NotSubscriptable()[0]  # error: "Cannot subscript object of type `NotSubscriptable` with no `__getitem__` method"
+```
+
+## Getitem not callable
+
+```py
+class NotSubscriptable:
+    __getitem__ = None
+
+a = NotSubscriptable()[0]  # error: "Method `__getitem__` of type `None` is not callable on object of type `NotSubscriptable`"
+```
+
+## Valid getitem
+
+```py
+class Identity:
+    def __getitem__(self, index: int) -> int:
+        return index
+
+a = Identity()[0]  
+reveal_type(a) # revealed: int
+```
+
+## Getitem union
+
+```py
+flag = True
+
+class Identity:
+    if flag:
+        def __getitem__(self, index: int) -> int:
+            return index
+    else:
+        def __getitem__(self, index: int) -> str:
+            return str(index)
+
+a = Identity()[0]  
+reveal_type(a) # revealed: int | str
+```

crates/red_knot_python_semantic/resources/mdtest/subscript/string.md

@@ -0,0 +1,32 @@
+# Subscript on strings
+
+## Simple
+
+```py
+s = 'abcde'
+
+a = s[0]
+b = s[1]
+c = s[-1]
+d = s[-2]
+e = s[8]        # error: [index-out-of-bounds] "Index 8 is out of bounds for string `Literal["abcde"]` with length 5"
+f = s[-8]       # error: [index-out-of-bounds] "Index -8 is out of bounds for string `Literal["abcde"]` with length 5"
+
+reveal_type(a)  # revealed: Literal["a"]
+reveal_type(b)  # revealed: Literal["b"]
+reveal_type(c)  # revealed: Literal["e"]
+reveal_type(d)  # revealed: Literal["d"]
+reveal_type(e)  # revealed: Unknown
+reveal_type(f)  # revealed: Unknown
+```
+
+## Function return
+
+```py
+def add(x: int, y: int) -> int:
+    return x + y
+
+a = 'abcde'[add(0, 1)]
+# TODO: Support overloads... Should be `str`
+reveal_type(a)  # revealed: @Todo
+```

crates/red_knot_python_semantic/resources/mdtest/subscript/tuple.md

@@ -0,0 +1,21 @@
+# Tuple subscripts
+
+## Basic
+
+```py
+t = (1, 'a', 'b')
+
+a = t[0]
+b = t[1]
+c = t[-1]
+d = t[-2]
+e = t[4]        # error: [index-out-of-bounds]
+f = t[-4]       # error: [index-out-of-bounds]
+
+reveal_type(a)  # revealed: Literal[1]
+reveal_type(b)  # revealed: Literal["a"]
+reveal_type(c)  # revealed: Literal["b"]
+reveal_type(d)  # revealed: Literal["a"]
+reveal_type(e)  # revealed: Unknown
+reveal_type(f)  # revealed: Unknown
+```