Fix undefined-variable false positive with metaclass in nested class

When an imported name was used as a `metaclass=` argument inside a
nested class within a method, pylint incorrectly flagged subsequent
uses of that name at module level as `undefined-variable`.

Root cause: `_check_classdef_metaclasses()` found the name in
enclosing scopes and `_check_metaclasses()` popped it directly from
`to_consume`, making it completely unresolvable. Subsequent references
to the same name triggered `undefined-variable`.

Fix: use `NamesConsumer.mark_as_consumed()` instead of raw dict pop.
This properly moves the name from `to_consume` to `consumed`, so:
1. The import is not flagged as unused (original intent)
2. Later references find the name in `consumed` and resolve correctly

Closes #10823

Author: worksbyfriday

doc/whatsnew/fragments/10823.false_positive

@@ -0,0 +1,4 @@
+Fix ``undefined-variable`` false positive when a name used as a ``metaclass``
+argument in a nested class is referenced again later in the module.
+
+Closes #10823

pylint/checkers/variables.py

@@ -3400,27 +3400,29 @@ def _check_imports(self, not_consumed: Consumption) -> None:
 
     def _check_metaclasses(self, node: nodes.Module | nodes.FunctionDef) -> None:
         """Update consumption analysis for metaclasses."""
-        consumed: list[tuple[Consumption, str]] = []
+        consumed: list[tuple[NamesConsumer, str, list[nodes.NodeNG]]] = []
 
         for child_node in node.get_children():
             if isinstance(child_node, nodes.ClassDef):
                 consumed.extend(self._check_classdef_metaclasses(child_node, node))
 
-        # Pop the consumed items, in order to avoid having
-        # unused-import and unused-variable false positives
-        for scope_locals, name in consumed:
-            scope_locals.pop(name, None)
+        # Mark the consumed items properly so they move from to_consume
+        # to consumed, avoiding unused-import/unused-variable false positives
+        # while still allowing subsequent references to resolve.
+        for consumer, name, found_nodes in consumed:
+            if name in consumer.to_consume:
+                consumer.mark_as_consumed(name, found_nodes)
 
     def _check_classdef_metaclasses(
         self,
         klass: nodes.ClassDef,
         parent_node: nodes.Module | nodes.FunctionDef,
-    ) -> list[tuple[Consumption, str]]:
+    ) -> list[tuple[NamesConsumer, str, list[nodes.NodeNG]]]:
         if not klass._metaclass:
             # Skip if this class doesn't use explicitly a metaclass, but inherits it from ancestors
             return []
 
-        consumed: list[tuple[Consumption, str]] = []
+        consumed: list[tuple[NamesConsumer, str, list[nodes.NodeNG]]] = []
         metaclass = klass.metaclass()
         name = ""
         match klass._metaclass:
@@ -3446,7 +3448,7 @@ def _check_classdef_metaclasses(
                 found_nodes = scope_locals.get(name, [])
                 for found_node in found_nodes:
                     if found_node.lineno <= klass.lineno:
-                        consumed.append((scope_locals, name))
+                        consumed.append((to_consume, name, found_nodes))
                         found = True
                         break
             # Check parent scope

tests/functional/u/undefined/undefined_variable_metaclass_nested.py

@@ -0,0 +1,20 @@
+"""Tests for undefined-variable false positive when a name is used as a metaclass
+in a nested class inside a method, and then used again at module level.
+
+https://github.com/pylint-dev/pylint/issues/10823
+"""
+# pylint: disable=too-few-public-methods,missing-class-docstring,missing-function-docstring
+# pylint: disable=unused-variable,pointless-statement
+
+import abc
+
+
+class Test:
+    def test1(self):
+        class A(metaclass=abc.ABCMeta):
+            pass
+
+
+# This should NOT trigger undefined-variable — abc was imported at module level
+# and consumed by the metaclass usage, but it should still be resolvable.
+abc.ABCMeta