gh-37369: Faster scalar multiplication for python types
    
There is an annoying problem at the moment. If you compute the scalar
multiplication of a point on an elliptic curve over a finite field, a
fast call to Pari is made when the scalar is a Sage type, but when the
scalar is a Python `int` then the multiplication for `_acted_upon_` is
skipped by the coercion system and `__mul__` is called instead which is
a much slower Sage implementation using double and add.

As an example of this see the following run times.

```py
┌────────────────────────────────────────────────────────────────────┐
│ SageMath version 10.2, Release Date: 2023-12-03                    │
│ Using Python 3.11.4. Type "help()" for help.                       │
└────────────────────────────────────────────────────────────────────┘
sage: F = GF(2**127 - 1)
sage: E = EllipticCurve(F, [0,6,0,1,0])
sage: P = E.random_point()
sage: k = randint(0, 2**127)
sage:
sage: %timeit int(k) * P
3.77 ms ± 98.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
sage: %timeit P * int(k)
3.74 ms ± 12.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
sage: %timeit ZZ(k) * P
235 µs ± 2.62 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
sage: %timeit P * ZZ(k)
234 µs ± 4.81 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
```

This is particularly annoying if you write Sagemath code in a `.py` file
and write
`2**100 * P`, which will be parsed such that `2**100` is an `int` and
the very slow method is used. For this 127-bit characteristic example
above, the slowdown is more than a factor of 10.

This PR writes small methods for `__mul__` and `__rmul__` which wrap
`_acted_upon_` and allow the speed up for Python `int` values. This
results in the following times for the same example:

```py
┌────────────────────────────────────────────────────────────────────┐
│ SageMath version 10.3.beta8, Release Date: 2024-02-13              │
│ Using Python 3.11.4. Type "help()" for help.                       │
└────────────────────────────────────────────────────────────────────┘
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Warning: this is a prerelease version, and it may be unstable.     ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
sage: F = GF(2**127 - 1)
sage: E = EllipticCurve(F, [0,6,0,1,0])
sage: P = E.random_point()
sage: k = randint(0, 2**127)
sage:
sage: %timeit int(k) * P
222 µs ± 1.6 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
sage: %timeit P * int(k)
225 µs ± 4.54 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
sage: %timeit ZZ(k) * P
219 µs ± 1.88 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
sage: %timeit P * ZZ(k)
230 µs ± 15.6 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
```
    
URL: #37369
Reported by: Giacomo Pope
Reviewer(s): John Cremona, nbruin

Author: Release Manager

src/sage/structure/parent.pyx

@@ -2635,6 +2635,25 @@ cdef class Parent(sage.structure.category_object.CategoryObject):
 
             sage: print(coercion_model.get_action(E, ZZ, operator.pow))                 # needs sage.schemes
             None
+
+        ::
+
+            With Pull Request #37369, registered multiplication actions by
+            `ZZ` are also discovered and used when a Python ``int`` is multiplied.
+            Previously, it was only discovering the generic Integer Multiplication
+            Action that all additive groups have. As a result, optimised
+            implementations, such as the use of Pari for scalar multiplication of points
+            on elliptic curves over Finite Fields, was not used if an ``int``
+            multiplied a point, resulting in a 10x slowdown for large characteristic::
+
+            sage: E = EllipticCurve(GF(17),[1,1])
+            sage: coercion_model.discover_action(ZZ, E, operator.mul)
+            Left action by Integer Ring on Elliptic Curve defined by y^2 = x^3 + x + 1 over Finite Field of size 17
+            sage: coercion_model.discover_action(int, E, operator.mul)
+            Left action by Integer Ring on Elliptic Curve defined by y^2 = x^3 + x + 1 over Finite Field of size 17
+            with precomposition on left by Native morphism:
+            From: Set of Python objects of class 'int'
+            To:   Integer Ring
         """
         # G acts on S, G -> G', R -> S => G' acts on R (?)
         # NO! ZZ[x,y] acts on Matrices(ZZ[x]) but ZZ[y] does not.
@@ -2678,6 +2697,33 @@ cdef class Parent(sage.structure.category_object.CategoryObject):
                     return action
 
                 if parent_is_integers(S) and not self.has_coerce_map_from(S):
+                    # Try the above again, but first coerce integer-like type to Integer
+                    # with a connecting coercion
+                    global _Integer
+                    if _Integer is None:
+                        from sage.rings.integer import Integer as _Integer
+                    ZZ_el = _Integer(S_el)
+                    ZZ = ZZ_el.parent()
+
+                    # Now we check if there's an element action from Integers
+                    action = detect_element_action(self, ZZ, self_on_left, self_el, ZZ_el)
+
+                    # When this is not None, we can do the Precomposed action
+                    if action is not None:
+                        # Compute the coercion from whatever S is to the Integer class
+                        # This should always work because parent_is_integers(S) is True
+                        # but it fails when S is gmpy2.mpz.
+                        # TODO: should we also patch _internal_coerce_map_from so that
+                        # there's a map from gmpy2.mpz to ZZ?
+                        connecting = ZZ._internal_coerce_map_from(S)
+                        if connecting is not None:
+                            if self_on_left:
+                                action = PrecomposedAction(action, None, connecting)
+                            else:
+                                action = PrecomposedAction(action, connecting, None)
+                            return action
+
+                    # Otherwise, we do the most basic IntegerMulAction
                     from sage.structure.coerce_actions import IntegerMulAction
                     try:
                         return IntegerMulAction(S, self, not self_on_left, self_el)