Fix CI: remove trailing spaces in check files

Author: liufengyun

tests/neg/classOf.check

@@ -6,7 +6,7 @@
 7 |  def f2[T <: String] = classOf[T] // error
   |                                ^
   |                                T is not a class type
-  |                                
+  |
   |                                where:    T is a type in method f2 with bounds <: String
 -- Error: tests/neg/classOf.scala:9:18 ---------------------------------------------------------------------------------
 9 |  val y = classOf[C { type I = String }] // error

tests/neg/i5433.check

@@ -3,7 +3,7 @@
    |      ^
    |      class Fail cannot be defined due to a conflict between its parents when
    |      implementing a super-accessor for foo in trait C:
-   |      
+   |
    |      1. One of its parent (C) contains a call super.foo in its body,
    |         and when a super-call in a trait is written without an explicit parent
    |         listed in brackets, it is implemented by a generated super-accessor in
@@ -19,9 +19,9 @@
    |         Y (the type of foo in trait C).
    |         Hence, the super-accessor that needs to be generated in Fail
    |         is illegal.
-   |      
+   |
    |      Here are two possible ways to resolve this:
-   |      
+   |
    |      1. Change the linearization order of Fail such that
    |         C comes before B.
    |      2. Alternatively, replace super.foo in the body of trait C by a

tests/neg/subtyping.check

@@ -3,16 +3,16 @@
   |                           ^
   |                           Cannot prove that B#X <:< A#X..
   |                           I found:
-  |                           
+  |
   |                               <:<.refl[Nothing]
-  |                           
+  |
   |                           But method refl in object <:< does not match type B#X <:< A#X.
 -- Error: tests/neg/subtyping.scala:12:27 ------------------------------------------------------------------------------
 12 |    implicitly[a.T <:< a.U] // error: no implicit argument
    |                           ^
    |                           Cannot prove that a.T <:< a.U..
    |                           I found:
-   |                           
+   |
    |                               <:<.refl[Nothing]
-   |                           
+   |
    |                           But method refl in object <:< does not match type a.T <:< a.U.