gh-37318: Allowing HeckeAlgebraSymmetricGroupT to accept elements of SymmetricGroup(n) as input
    
<!-- ^^^^^
Please provide a concise, informative and self-explanatory title.
Don't put issue numbers in there, do this in the PR body below.
For example, instead of "Fixes #1234" use "Introduce new method to
calculate 1+1"
-->
<!-- Describe your changes here in detail -->

Currently, the following fails in sage:
```
sage: S4 = SymmetricGroup(4)
sage: H4 = HeckeAlgebraSymmetricGroupT(ZZ, 4)
sage: H4( Permutations(4).an_element() )
T[4, 1, 2, 3]
sage: H4( S4.an_element() )
Traceback (most recent call last)
...
TypeError: do not know how to make x (= (2,3,4)) an element of self
(=Hecke algebra of the symmetric group of order 4 on the T basis over
Univariate Polynomial Ring in q over Integer Ring)
```
I view this as a bug because the elements of this algebra are indexed by
elements of the symmetric group and `HeckeAlgebraSymmetricGroupT` does
accept elements of `Permutations(n)`.

This PR makes works work as well as accepting elements of
`Permutations(N)`, for `N>n, that fix `n+1,...,N`.

Previously, `HeckeAlgebraSymmetricGroupT` contain a `_coerce_start`
method. I have renamed this as `_element_constructor_`, which is what I
think it should be, and made some minor changes there. Probably, I
should deprecate `_coerce_start` but this method does not seem to exist
anywhere else in sage, so I suspect that this belongs to some code that
was deprecated years ago.



<!-- Why is this change required? What problem does it solve? -->
<!-- If this PR resolves an open issue, please link to it here. For
example "Fixes #12345". -->
<!-- If your change requires a documentation PR, please link it
appropriately. -->

### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. -->
<!-- If your change requires a documentation PR, please link it
appropriately -->
<!-- If you're unsure about any of these, don't hesitate to ask. We're
here to help! -->
<!-- Feel free to remove irrelevant items. -->

- [x] The title is concise, informative, and self-explanatory.
- [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.
- [x] I have updated the documentation accordingly.

### ⌛ Dependencies

<!-- List all open PRs that this PR logically depends on
- #12345: short description why this is a dependency
- #34567: ...
-->

<!-- If you're unsure about any of these, don't hesitate to ask. We're
here to help! -->
    
URL: #37318
Reported by: Andrew Mathas
Reviewer(s): Andrew Mathas, Giacomo Pope

Author: Release Manager

src/sage/combinat/symmetric_group_algebra.py

@@ -3004,6 +3004,13 @@ def HeckeAlgebraSymmetricGroupT(R, n, q=None):
         [2, 3, 1]
 
         sage: TestSuite(H3).run()
+
+    .. NOTE::
+
+        :class:`~sage.algebras.iwahori_hecke_algebra.IwahoriHeckeAlgebra` gives
+        a different implementation of the Iwahori-Hecke algebras of a Coxeter
+        system `(W,S)`. This includes the Hecke algebras of the symmetric group
+        as special case.
     """
     return HeckeAlgebraSymmetricGroup_t(R, n, q)
 
@@ -3065,24 +3072,34 @@ def q(self):
         """
         return self._q
 
-    def _coerce_start(self, x):
+    def _element_constructor_(self, x):
         """
         EXAMPLES::
 
             sage: H3 = HeckeAlgebraSymmetricGroupT(QQ, 3)
-            sage: H3._coerce_start([2,1])
+            sage: H3([2,1])  # indirect doc test
+            T[2, 1, 3]
+            sage: H3( Permutations(3).an_element() )
+            T[3, 1, 2]
+            sage: H3( SymmetricGroup(3).an_element() )
+            [1, 3, 2]
+            sage: H3( [2, 1, 3, 4, 5, 6] )
             T[2, 1, 3]
         """
         ###################################################
         # Coerce permutations of size smaller that self.n #
         ###################################################
         if not x:
             return self.one()
-        if len(x) < self.n and x in Permutations():
-            return self.monomial(self._indices(list(x) +
-                                               list(range(len(x) + 1,
-                                                          self.n + 1))))
-        raise TypeError
+        if x in Permutations():
+            if len(x) < self.n:
+                return self.monomial(self._indices(
+                            list(x) + list(range(len(x) + 1, self.n + 1))
+                        ))
+            if all(x[i] == i+1 for i in range(self.n, len(x))):
+                return self.monomial(self._indices(x[:self.n]))
+
+        return self._indices(x)
 
 
 class HeckeAlgebraSymmetricGroup_t(HeckeAlgebraSymmetricGroup_generic):