Avoid silent overflow in /(x::Rational, y::Complex{Int}) (#53453)

This change catches the overflow in 
```julia
(Int8(1)//Int8(1)) / (Int8(100) + Int8(100)im)
```
instead of incorrectly returning 
```julia
25//8 - 25//8*im
```

This PR removes some of the specific `/` methods that involve complex
rationals in `rational.jl`.
The default methods in `complex.jl` have better promotion rules and edge
case checking. This includes the checks added in #32050, fixing #23134
for rational numbers.

The previous dispatch to `//` ignored overflow errors (see #53435), but
would return the correct answer if the numerator was zero even if the
denominator would overflow.

---------

Co-authored-by: Neven Sajko <[email protected]>

Author: nhz2

base/rational.jl

@@ -421,8 +421,8 @@ function *(x::Bool, y::T)::promote_type(Bool,T) where T<:Rational
     return ifelse(x, y, copysign(zero(y), y))
 end
 *(y::Rational, x::Bool) = x * y
-/(x::Rational, y::Union{Rational, Integer, Complex{<:Union{Integer,Rational}}}) = x//y
-/(x::Union{Integer, Complex{<:Union{Integer,Rational}}}, y::Rational) = x//y
+/(x::Rational, y::Union{Rational, Integer}) = x//y
+/(x::Integer, y::Rational) = x//y
 inv(x::Rational{T}) where {T} = checked_den(x.den, x.num)
 
 fma(x::Rational, y::Rational, z::Rational) = x*y+z

test/rational.jl

@@ -203,6 +203,21 @@ end
     end
 
     @test Rational(rand_int, 3)/Complex(3, 2) == Complex(Rational(rand_int, 13), -Rational(rand_int*2, 39))
+    @test (1//1) / complex(0, 1) === 0//1 - 1//1*im
+    @test (0//1) / complex(0, 1) === 0//1 + 0//1*im
+    @test (0//1) / complex(1, 0) === 0//1 + 0//1*im
+    @test (0//1) / complex(1, 1) === 0//1 + 0//1*im
+    @test (1//1) / complex(1, 1) === 1//2 - 1//2*im
+    @test (0//1) / complex(1//1, 1//1) === 0//1 + 0//1*im
+    @test (1//1) / complex(1//1, 1//1) === 1//2 - 1//2*im
+    @test (0//1) / complex(1//0, 0//1) === 0//1 + 0//1*im
+    @test (1//1) / complex(1//1, 1//0) === 0//1 + 0//1*im
+    @test_throws DivideError (0//1) / complex(0, 0)
+    @test_throws DivideError (1//1) / complex(0, 0)
+    @test_throws DivideError (1//0) / complex(0, 0)
+
+    # 1//200 - 1//200*im cannot be represented as Complex{Rational{Int8}}
+    @test_throws OverflowError (Int8(1)//Int8(1)) / (Int8(100) + Int8(100)im)
 
     @test Complex(rand_int, 0) == Rational(rand_int)
     @test Rational(rand_int) == Complex(rand_int, 0)