[ty] Add support for @staticmethods (#18809)

## Summary

Add support for `@staticmethod`s. Overall, the changes are very similar
to #16305.

#18587 will be dependent on this PR for a potential fix of
https://github.com/astral-sh/ty/issues/207.

mypy_primer will look bad since the new code allows ty to check more
code.

## Test Plan

Added new markdown tests. Please comment if there's any missing tests
that I should add in, thank you.

crates/ty_python_semantic/resources/mdtest/call/methods.md

@@ -430,4 +430,112 @@ reveal_type(C.f2(1))  # revealed: str
 reveal_type(C().f2(1))  # revealed: str
 ```
 
+## `@staticmethod`
+
+### Basic
+
+When a `@staticmethod` attribute is accessed, it returns the underlying function object. This is
+true whether it's accessed on the class or on an instance of the class.
+
+```py
+from __future__ import annotations
+
+class C:
+    @staticmethod
+    def f(x: int) -> str:
+        return "a"
+
+reveal_type(C.f)  # revealed: def f(x: int) -> str
+reveal_type(C().f)  # revealed: def f(x: int) -> str
+```
+
+The method can then be called like a regular function from either the class or an instance, with no
+implicit first argument passed.
+
+```py
+reveal_type(C.f(1))  # revealed: str
+reveal_type(C().f(1))  # revealed: str
+```
+
+When the static method is called incorrectly, we detect it:
+
+```py
+C.f("incorrect")  # error: [invalid-argument-type]
+C.f()  # error: [missing-argument]
+C.f(1, 2)  # error: [too-many-positional-arguments]
+```
+
+When a static method is accessed on a derived class, it behaves identically:
+
+```py
+class Derived(C):
+    pass
+
+reveal_type(Derived.f)  # revealed: def f(x: int) -> str
+reveal_type(Derived().f)  # revealed: def f(x: int) -> str
+
+reveal_type(Derived.f(1))  # revealed: str
+reveal_type(Derived().f(1))  # revealed: str
+```
+
+### Accessing the staticmethod as a static member
+
+```py
+from inspect import getattr_static
+
+class C:
+    @staticmethod
+    def f(): ...
+```
+
+Accessing the staticmethod as a static member. This will reveal the raw function, as `staticmethod`
+is transparent when accessed via `getattr_static`.
+
+```py
+reveal_type(getattr_static(C, "f"))  # revealed: def f() -> Unknown
+```
+
+The `__get__` of a `staticmethod` object simply returns the underlying function. It ignores both the
+instance and owner arguments.
+
+```py
+reveal_type(getattr_static(C, "f").__get__(None, C))  # revealed: def f() -> Unknown
+reveal_type(getattr_static(C, "f").__get__(C(), C))  # revealed: def f() -> Unknown
+reveal_type(getattr_static(C, "f").__get__(C()))  # revealed: def f() -> Unknown
+reveal_type(getattr_static(C, "f").__get__("dummy", C))  # revealed: def f() -> Unknown
+```
+
+### Staticmethods mixed with other decorators
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+When a `@staticmethod` is additionally decorated with another decorator, it is still treated as a
+static method:
+
+```py
+from __future__ import annotations
+
+def does_nothing[T](f: T) -> T:
+    return f
+
+class C:
+    @staticmethod
+    @does_nothing
+    def f1(x: int) -> str:
+        return "a"
+
+    @does_nothing
+    @staticmethod
+    def f2(x: int) -> str:
+        return "a"
+
+reveal_type(C.f1(1))  # revealed: str
+reveal_type(C().f1(1))  # revealed: str
+reveal_type(C.f2(1))  # revealed: str
+reveal_type(C().f2(1))  # revealed: str
+```
+
 [functions and methods]: https://docs.python.org/3/howto/descriptor.html#functions-and-methods

crates/ty_python_semantic/resources/mdtest/descriptor_protocol.md

@@ -549,6 +549,19 @@ reveal_type(C.get_name())  # revealed: str
 reveal_type(C("42").get_name())  # revealed: str
 ```
 
+### Built-in `staticmethod` descriptor
+
+```py
+class C:
+    @staticmethod
+    def helper(value: str) -> str:
+        return value
+
+reveal_type(C.helper("42"))  # revealed: str
+c = C()
+reveal_type(c.helper("string"))  # revealed: str
+```
+
 ### Functions as descriptors
 
 Functions are descriptors because they implement a `__get__` method. This is crucial in making sure

crates/ty_python_semantic/resources/mdtest/overloads.md

@@ -449,30 +449,32 @@ from __future__ import annotations
 from typing import overload
 
 class CheckStaticMethod:
-    # TODO: error because `@staticmethod` does not exist on all overloads
     @overload
     def method1(x: int) -> int: ...
     @overload
     def method1(x: str) -> str: ...
     @staticmethod
+    # error: [invalid-overload] "Overloaded function `method1` does not use the `@staticmethod` decorator consistently"
     def method1(x: int | str) -> int | str:
         return x
-    # TODO: error because `@staticmethod` does not exist on all overloads
+
     @overload
     def method2(x: int) -> int: ...
     @overload
     @staticmethod
     def method2(x: str) -> str: ...
     @staticmethod
+    # error: [invalid-overload]
     def method2(x: int | str) -> int | str:
         return x
-    # TODO: error because `@staticmethod` does not exist on the implementation
+
     @overload
     @staticmethod
     def method3(x: int) -> int: ...
     @overload
     @staticmethod
     def method3(x: str) -> str: ...
+    # error: [invalid-overload]
     def method3(x: int | str) -> int | str:
         return x