Fix: Napoleon NumpyDocstring incorrect section ordering (Closes #13180)

Implements section reordering in NumpyDocstring._parse to ensure 'Attributes'
and 'Methods' sections appear after 'Parameters', matching numpydoc standard
logic.

This is achieved by collecting sections during parsing then reordering them
before generating the final parsed lines.

Author: DavidAGInnovation

sphinx/ext/napoleon/docstring.py

@@ -225,18 +225,15 @@ def _convert_type_spec(
     combined_tokens = _recombine_set_tokens(tokens)
     types = [(token, _token_type(token, debug_location)) for token in combined_tokens]
 
-    converters = {
+    converters: dict[str, Callable[[str], str]] = {
         'literal': lambda x: f'``{x}``',
         'obj': lambda x: _convert_type_spec_obj(x, translations),
         'control': lambda x: f'*{x}*',
         'delimiter': lambda x: x,
         'reference': lambda x: x,
     }
 
-    converted = ''.join(
-        converters.get(type_)(token)  # type: ignore[misc]
-        for token, type_ in types
-    )
+    converted = ''.join(converters[type_](token) for token, type_ in types)
 
     return converted
 
@@ -1220,6 +1217,64 @@ def __init__(
         self._directive_sections = ['.. index::']
         super().__init__(docstring, config, app, what, name, obj, options)
 
+    def _parse(self) -> None:
+        self._parsed_lines = self._consume_empty()
+
+        if self._name and self._what in {'attribute', 'data', 'property'}:
+            res: list[str] = []
+            with contextlib.suppress(StopIteration):
+                res = self._parse_attribute_docstring()
+
+            self._parsed_lines.extend(res)
+            return
+
+        sections: list[tuple[str, list[str]]] = []
+
+        while self._lines:
+            if self._is_section_header():
+                try:
+                    section = self._consume_section_header()
+                    self._is_in_section = True
+                    self._section_indent = self._get_current_indent()
+                    if _directive_regex.match(section):
+                        lines = [section, *self._consume_to_next_section()]
+                        sections.append((section, lines))
+                    else:
+                        lines = self._sections[section.lower()](section)
+                        sections.append((section.lower(), lines))
+                finally:
+                    self._is_in_section = False
+                    self._section_indent = 0
+            else:
+                if not self._parsed_lines and not sections:
+                    lines = self._consume_contiguous() + self._consume_empty()
+                    self._parsed_lines.extend(lines)
+                else:
+                    lines = self._consume_to_next_section()
+                    sections.append(('_msg', lines))
+
+        # Reorder sections: Attributes and Methods should come after Parameters
+        excluded_sections = {'attributes', 'methods'}
+        attributes_secs = [s for s in sections if s[0] == 'attributes']
+        methods_secs = [s for s in sections if s[0] == 'methods']
+        other_secs = [s for s in sections if s[0] not in excluded_sections]
+
+        insert_idx = 0
+        for i, (name, _section_lines) in enumerate(other_secs):
+            if name == 'parameters':
+                insert_idx = i + 1
+                break
+
+        final_sections = (
+            other_secs[:insert_idx]
+            + attributes_secs
+            + methods_secs
+            + other_secs[insert_idx:]
+        )
+
+        for _name, lines in final_sections:
+            self._parsed_lines.extend(lines)
+
     def _escape_args_and_kwargs(self, name: str) -> str:
         func = super()._escape_args_and_kwargs