gh-40279: Fix RealLiteral to float conversion
    
Previously we see the following behavior

    sage: float(1.133759543500045e+153)
    1.1337595435000451e+153
    sage: float('1.133759543500045e+153')
    1.133759543500045e+153

This is because `RealLiteral` constructor determine `prec=54`, so the
string `1.133759543500045e+153` is first converted to 54 bits, then
rounded to 53 bits. This introduces the error because of [double
rounding](https://en.wikipedia.org/wiki/Rounding#Double_rounding).

Also fix the issue where `n(RealNumber('12', base=16))` returns 12. (now
it correctly returns 18.)

### 📝 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: #40279
Reported by: user202729
Reviewer(s): Martin Rubey, user202729

Author: Release Manager

src/sage/rings/real_mpfr.pyx

@@ -5694,28 +5694,29 @@ cdef class RealLiteral(RealNumber):
     casting into higher precision rings.
     """
 
-    cdef readonly literal
+    cdef readonly str literal
     cdef readonly int base
 
-    def __init__(self, RealField_class parent, x=0, int base=10):
+    def __init__(self, RealField_class parent, str x, int base=10):
         """
         Initialize ``self``.
 
+        Note that the constructor parameters are first passed to :meth:`RealNumber.__cinit__`.
+
         EXAMPLES::
 
             sage: RealField(200)(float(1.3))
             1.3000000000000000444089209850062616169452667236328125000000
-            sage: RealField(200)(1.3)
+            sage: RealField(200)(1.3)  # implicit doctest
             1.3000000000000000000000000000000000000000000000000000000000
             sage: 1.3 + 1.2
             2.50000000000000
             sage: RR(1_0000.000000000000000000000000000000000000)
             10000.0000000000
         """
         RealNumber.__init__(self, parent, x, base)
-        if isinstance(x, str):
-            self.base = base
-            self.literal = x.replace('_', '')
+        self.base = base
+        self.literal = x.replace('_', '')
 
     def __neg__(self):
         """
@@ -5728,10 +5729,25 @@ cdef class RealLiteral(RealNumber):
             sage: RealField(300)(-(-1.2))
             1.20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
         """
-        if self.literal is not None and self.literal[0] == '-':
+        if self.literal[0] == '-':
             return RealLiteral(self._parent, self.literal[1:], self.base)
-        else:
-            return RealLiteral(self._parent, '-'+self.literal, self.base)
+        return RealLiteral(self._parent, '-' + self.literal, self.base)
+
+    def __float__(self):
+        """
+        Return a Python float approximating ``self``.
+        This override is needed to avoid issues with rounding twice,
+        thus guaranteeing round-trip.
+
+        TESTS::
+
+            sage: float(1.133759543500045e+153)
+            1.133759543500045e+153
+            sage: for i in range(1000):
+            ....:     x = float(randint(1, 2**53) << randint(1, 200))
+            ....:     assert float(eval(preparse(str(x)))) == x, x
+        """
+        return float(self.numerical_approx(53))
 
     def numerical_approx(self, prec=None, digits=None, algorithm=None):
         """
@@ -5774,10 +5790,15 @@ cdef class RealLiteral(RealNumber):
             <class 'sage.rings.real_mpfr.RealLiteral'>
             sage: type(n(1.3))
             <class 'sage.rings.real_mpfr.RealNumber'>
+
+        TESTS::
+
+            sage: n(RealNumber('12', base=16))  # abs tol 1e-14
+            18.0000000000000
         """
         if prec is None:
             prec = digits_to_bits(digits)
-        return RealField(prec)(self.literal)
+        return RealField(prec)(self.literal, self.base)
 
 
 RR = RealField()