gh-40717: Fix enumerating the same cycle twice in undirected graph
    
<!-- ^ Please provide a concise and informative title. -->
<!-- ^ Don't put issue numbers in the title, do this in the PR
description below. -->
<!-- ^ For example, instead of "Fixes #12345" use "Introduce new method
to calculate 1 + 2". -->
<!-- v Describe your changes below in detail. -->
<!-- v Why is this change required? What problem does it solve? -->
<!-- v If this PR resolves an open issue, please link to it here. For
example, "Fixes #12345". -->

The output for `algorithm="A"` and `algorithm="B"` in
all_cycles_iterator function  is inconsistent as below.
This happens when a graph is undirected. `algorithm="A"` outputs the
same cycle in reverse order, while `algorithm="B"` does not.

```python
sage: g = Graph({0: [1, 2], 1: [0, 2], 2: [0, 1]})
sage: list(g.all_cycles_iterator(algorithm='A', simple=True))
[[0, 1, 2, 0], [0, 2, 1, 0]]
sage: list(g.all_cycles_iterator(algorithm='B', simple=True))
[[0, 1, 2, 0]]
```

This PR fixes this issue by changing the current bahavior of
`algorithm="A"` and output each cycle once.


### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. -->

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.
- [x] I have linked a relevant issue or discussion.
- [x] I have created tests covering the changes.
- [ ] I have updated the documentation and checked the documentation
preview.

### ⌛ Dependencies

<!-- List all open PRs that this PR logically depends on. For example,
-->
<!-- - #12345: short description why this is a dependency -->
<!-- - #34567: ... -->
    
URL: #40717
Reported by: Yuta Inoue
Reviewer(s): David Coudert, Yuta Inoue

Author: Release Manager

src/sage/graphs/cycle_enumeration.py

@@ -156,22 +156,22 @@ def _all_cycles_iterator_vertex(self, vertex, starting_vertices=None, simple=Fal
         ...
         ValueError: negative weight is not allowed
 
-    The function works for an undirected graph::
+    The function works for an undirected graph. Specifically, each cycle is
+    enumerated exactly once, meaning a cycle and its reverse are not listed separately::
 
         sage: g = Graph({0: [1, 2], 1: [0, 2], 2: [0, 1]})
         sage: it = g._all_cycles_iterator_vertex(0, simple=False)
         sage: for i in range(7): print(next(it))
         [0, 1, 0]
         [0, 2, 0]
         [0, 1, 2, 0]
-        [0, 2, 1, 0]
         [0, 1, 0, 1, 0]
         [0, 1, 0, 2, 0]
         [0, 1, 2, 1, 0]
+        [0, 2, 0, 2, 0]
         sage: for cycle in g._all_cycles_iterator_vertex(0, simple=True):
         ....:     print(cycle)
         [0, 1, 2, 0]
-        [0, 2, 1, 0]
     """
     if starting_vertices is None:
         starting_vertices = [vertex]
@@ -195,6 +195,8 @@ def _all_cycles_iterator_vertex(self, vertex, starting_vertices=None, simple=Fal
             h.delete_edges((u, v) for u, v in h.edge_iterator(labels=False) if d[u] != d[v])
     else:
         h = self
+        int_to_vertex = list(h)
+        vertex_to_int = {v: i for i, v in enumerate(int_to_vertex)}
 
     by_weight, weight_function = self._get_weight_function(by_weight=by_weight,
                                                            weight_function=weight_function,
@@ -212,12 +214,24 @@ def _all_cycles_iterator_vertex(self, vertex, starting_vertices=None, simple=Fal
     while heap_queue:
         length, path = heappop(heap_queue)
         # Checks if a cycle has been found
-        if len(path) > 1 and path[0] == path[-1] and \
-           (not simple or self.is_directed() or len(path) > 3):
-            if report_weight:
-                yield (length, path)
-            else:
-                yield path
+        if len(path) > 1 and path[0] == path[-1]:
+            report = True
+            if not self.is_directed():
+                if simple:
+                    report = len(path) > 3 and vertex_to_int[path[1]] < vertex_to_int[path[-2]]
+                else:
+                    L = len(path)
+                    for i in range(1, L // 2):
+                        if vertex_to_int[path[i]] > vertex_to_int[path[L - i - 1]]:
+                            report = False
+                            break
+                        if vertex_to_int[path[i]] < vertex_to_int[path[L - i - 1]]:
+                            break
+            if report:
+                if report_weight:
+                    yield (length, path)
+                else:
+                    yield path
         # If simple is set to True, only simple cycles are
         # allowed, Then it discards the current path
         if (not simple or path.count(path[-1]) == 1):
@@ -559,7 +573,7 @@ def all_cycles_iterator(self, starting_vertices=None, simple=False,
         [0, 1, 2, 0]
         [2, 3, 4, 5, 2]
 
-    The algorithm ``'B'`` is available only when `simple=True`::
+    The algorithm ``'B'`` is available only when ``simple=True``::
 
         sage: g = DiGraph()
         sage: g.add_edges([('a', 'b', 1), ('b', 'a', 1)])
@@ -569,13 +583,13 @@ def all_cycles_iterator(self, starting_vertices=None, simple=False,
         ...
         ValueError: The algorithm 'B' is available only when simple=True.
 
-    The algorithm ``'A'`` works for undirected graphs as well::
+    The algorithm ``'A'`` works for undirected graphs as well. Specifically, each cycle is
+    enumerated exactly once, meaning a cycle and its reverse are not listed separately::
 
         sage: g = Graph({0: [1, 2], 1: [0, 2], 2: [0, 1]})
         sage: for cycle in g.all_cycles_iterator(algorithm='A', simple=True):
         ....:     print(cycle)
         [0, 1, 2, 0]
-        [0, 2, 1, 0]
     """
     if starting_vertices is None:
         starting_vertices = self
@@ -872,11 +886,12 @@ def all_simple_cycles(self, starting_vertices=None, rooted=False,
         sage: cycles.sort() == cycles_B.sort()
         True
 
-    The algorithm ``'A'`` is available for undirected graphs::
+    The algorithm ``'A'`` is available for undirected graphs. Specifically, each cycle is
+    enumerated exactly once, meaning a cycle and its reverse are not listed separately::
 
         sage: g = Graph({0: [1, 2], 1: [0, 2], 2: [0, 1]})
         sage: g.all_simple_cycles(algorithm='A')
-        [[0, 1, 2, 0], [0, 2, 1, 0]]
+        [[0, 1, 2, 0]]
     """
     return list(self.all_cycles_iterator(starting_vertices=starting_vertices,
                                          simple=True, rooted=rooted,