gh-40223: Implement algorithm=generic_small and algorithm=hybrid for elliptic curve points
    
The main purpose of this is to be able to do the following (from
doctest)

            sage: # needs sage.rings.finite_rings
            sage: p = next_prime(2^256)
            sage: q = next_prime(p)
            sage: E = EllipticCurve(GF(660*p*q-1), [1, 0])
            sage: P = E.lift_x(11) * p * q
            sage: P.order()  # not tested (pari will try to factor p*q
which takes forever)
            sage: P.order(algorithm='generic_small')
            330
            sage: P.order()  # works due to caching
            330


Also fix some minor issues.

It might be preferable to upstream this to pari as well.

Also, this improvement idea can be applied more generally, namely to
`order_from_multiple`. However, that complicate the implementation
somewhat. I decide to leave that for later, if there is interest.

### 📝 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.
- [ ] I have linked a relevant issue or discussion.
- [x] I have created tests covering the changes.
- [x] 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: #40223
Reported by: user202729
Reviewer(s): John Cremona, Sahil Jain, user202729

Author: Release Manager

src/sage/groups/generic.py

@@ -458,6 +458,15 @@ def bsgs(a, b, bounds, operation='*', identity=None, inverse=None, op=None):
     AUTHOR:
 
     - John Cremona (2008-03-15)
+
+    TESTS:
+
+    Ensures Python integers work::
+
+        sage: from sage.groups.generic import bsgs
+        sage: b = Mod(2,37);  a = b^20
+        sage: bsgs(b, a, (0r, 36r))
+        20
     """
     Z = integer_ring.ZZ
 
@@ -477,6 +486,8 @@ def bsgs(a, b, bounds, operation='*', identity=None, inverse=None, op=None):
             raise ValueError("identity, inverse and operation must be given")
 
     lb, ub = bounds
+    lb = Z(lb)
+    ub = Z(ub)
     if lb < 0 or ub < lb:
         raise ValueError("bsgs() requires 0<=lb<=ub")
 
@@ -1405,7 +1416,9 @@ def order_from_bounds(P, bounds, d=None, operation='+',
     - ``P`` -- a Sage object which is a group element
 
     - ``bounds`` -- a 2-tuple ``(lb,ub)`` such that ``m*P=0`` (or
-      ``P**m=1``) for some ``m`` with ``lb<=m<=ub``
+      ``P**m=1``) for some ``m`` with ``lb<=m<=ub``. If ``None``,
+      gradually increasing bounds will be tried (might loop infinitely
+      if the element has no torsion).
 
     - ``d`` -- (optional) a positive integer; only ``m`` which are
       multiples of this will be considered
@@ -1434,6 +1447,8 @@ def order_from_bounds(P, bounds, d=None, operation='+',
         sage: b = a^4
         sage: order_from_bounds(b, (5^4, 5^5), operation='*')
         781
+        sage: order_from_bounds(b, None, operation='*')
+        781
 
         sage: # needs sage.rings.finite_rings sage.schemes
         sage: E = EllipticCurve(k, [2,4])
@@ -1451,6 +1466,15 @@ def order_from_bounds(P, bounds, d=None, operation='+',
         sage: order_from_bounds(w, (200, 250), operation='*')
         23
     """
+    if bounds is None:
+        lb = 1
+        ub = 256
+        while True:
+            try:
+                return order_from_bounds(P, (lb, ub), d, operation, identity, inverse, op)
+            except ValueError:
+                lb = ub + 1
+                ub *= 16
     from operator import mul, add
 
     if operation in multiplication_names: