Please address the comments from this code review:

## Overall Comments
- The `resolver_defined_separately` check only inspects `cls.__dict__`, so resolvers inherited from base classes won’t be detected as “defined separately”; if that matters for your use case, consider walking the MRO or documenting/adjusting this behavior.
- The resolver-vs-field detection logic inside `_check_field_annotations` is getting fairly dense; consider extracting it into a small helper function to make the intent clearer and keep `_check_field_annotations` focused on control flow.

## Individual Comments

### Comment 1
<location path="strawberry/types/object_type.py" line_range="86-91" />
<code_context>
+                    # latter, MissingFieldAnnotationError is more helpful
+                    # since the user should annotate the field directly.
+                    resolver_func = field_.base_resolver.wrapped_func
+                    resolver_defined_separately = any(
+                        v is resolver_func
+                        for k, v in cls.__dict__.items()
+                        if k != field_name
+                        and callable(v)
+                        and not isinstance(v, StrawberryField)
+                    )
+                    if (
</code_context>
<issue_to_address>
**issue:** Resolver detection may miss classmethod/staticmethod-based resolvers and other descriptor wrappers.

Because this logic compares `v is resolver_func` over `cls.__dict__`, it will fail for `@classmethod` / `@staticmethod` or other descriptors used as `strawberry.field(resolver=MyClass.my_resolver)`. In those cases, `cls.__dict__` contains the descriptor (e.g. `classmethod`), not the underlying function, so `resolver_defined_separately` incorrectly remains `False`. To handle these cases, unwrap known descriptors (e.g. via `getattr(v, "__func__", v)`) before comparing to `resolver_func`.
</issue_to_address>

### Comment 2
<location path="tests/fields/test_resolvers.py" line_range="138" />
<code_context>
+    ),
 )
-def test_raises_error_when_return_annotation_missing_resolver():
+def test_raises_field_error_when_using_untyped_explicit_resolver():
     @strawberry.type
     class Query2:
</code_context>
<issue_to_address>
**suggestion (testing):** Add a test to cover the documented "known limitation" case where the resolver has the same name as the field.

The PR description mentions the specific case `goodbye = strawberry.field(resolver=goodbye)`, where the resolver in `cls.__dict__` is overwritten and we fall back to `MissingReturnAnnotationError`. Please add a dedicated test for this scenario to guard against regressions: define a type where `goodbye` is first declared as an unannotated function, then overwritten via `goodbye = strawberry.field(resolver=goodbye)`, and assert that `MissingReturnAnnotationError` (with the expected message) is raised.
</issue_to_address>

### Comment 3
<location path="tests/fields/test_resolvers.py" line_range="131-138" />
<code_context>


 @pytest.mark.raises_strawberry_exception(
-    MissingReturnAnnotationError,
-    match='Return annotation missing for field "goodbye", did you forget to add it?',
+    MissingFieldAnnotationError,
+    match=(
+        'Unable to determine the type of field "goodbye". Either annotate it '
+        "directly, or provide a typed resolver using @strawberry.field."
+    ),
 )
-def test_raises_error_when_return_annotation_missing_resolver():
+def test_raises_field_error_when_using_untyped_explicit_resolver():
     @strawberry.type
     class Query2:
</code_context>
<issue_to_address>
**suggestion (testing):** Add/keep a dedicated test ensuring the decorator-style resolver without return annotation still raises `MissingReturnAnnotationError`.

This change now tests the `strawberry.field(resolver=fn)` path and expects `MissingFieldAnnotationError`. To also cover the decorator path introduced in `_check_field_annotations`, please add a test for the `@strawberry.field` decorator with an untyped resolver and no field annotation, asserting that `MissingReturnAnnotationError` is raised. If that test already exists, consider co-locating or briefly documenting it to clarify the distinction between the two behaviors.

Suggested implementation:

```python
@pytest.mark.raises_strawberry_exception(
    MissingFieldAnnotationError,
    match=(
        'Unable to determine the type of field "goodbye". Either annotate it '
        "directly, or provide a typed resolver using @strawberry.field."
    ),
)
def test_raises_field_error_when_using_untyped_explicit_resolver():
    @strawberry.type
    class Query2:
        def adios(self):


@pytest.mark.raises_strawberry_exception(
    MissingReturnAnnotationError,
    match='Return annotation missing for field "hola", did you forget to add it?',
)
def test_raises_error_when_using_untyped_decorator_resolver():
    @strawberry.type
    class Query:
        @strawberry.field
        def hola(self):
            return "hola"

    strawberry.Schema(query=Query)

```

If this file does not already import `MissingReturnAnnotationError`, add it to the existing imports at the top of `tests/fields/test_resolvers.py`, alongside the other Strawberry exceptions.
</issue_to_address>