Faster Adjoint/Transpose-UniformScaling arithmetic (#1366)

Avoids hitting slow generic methods.
Discussed in
https://discourse.julialang.org/t/very-long-time-for-addition-of-complex-identity-matrix-to-transposed-sparse-matrix/129465.
After this, the following are comparable:
```julia
julia> A = sprandn(90, 90, 0.01);

julia> @Btime ($A + complex(0,1.) * I);
  1.313 μs (13 allocations: 8.02 KiB)

julia> @Btime (transpose($A) + complex(0,1.) * I);
  1.416 μs (13 allocations: 8.02 KiB)
```

Author: jishnub

src/uniformscaling.jl

@@ -217,6 +217,17 @@ function (-)(J::UniformScaling{<:Complex}, A::Hermitian)
     return B
 end
 
+function (+)(A::AdjOrTransAbsMat, J::UniformScaling)
+    checksquare(A)
+    op = wrapperop(A)
+    op(op(A) + op(J))
+end
+function (-)(J::UniformScaling, A::AdjOrTransAbsMat)
+    checksquare(A)
+    op = wrapperop(A)
+    op(op(J) - op(A))
+end
+
 function (+)(A::AbstractMatrix, J::UniformScaling)
     checksquare(A)
     B = copymutable_oftype(A, Base.promote_op(+, eltype(A), typeof(J)))

test/uniformscaling.jl

@@ -335,6 +335,19 @@ let
                 @test @inferred(J - T) == J - Array(T)
             end
 
+            @testset for f in (transpose, adjoint)
+                if isa(A, Array)
+                    T = f(randn(ComplexF64,3,3))
+                else
+                    T = f(view(randn(ComplexF64,3,3), 1:3, 1:3))
+                end
+                TA = Array(T)
+                @test @inferred(T + J) == TA + J
+                @test @inferred(J + T) == J + TA
+                @test @inferred(T - J) == TA - J
+                @test @inferred(J - T) == J - TA
+            end
+
             @test @inferred(I\A) == A
             @test @inferred(A\I) == inv(A)
             @test @inferred(λ\I) === UniformScaling(1/λ)