Add support for non-singleton arguments in singleton ops

These are simply checked as the supertype. For instance, `Int + Int`
is subtype of `Int`. This allows for more graceful failure when more 
general type arguments are provided.

compiler/src/dotty/tools/dotc/core/TypeComparer.scala

@@ -1039,7 +1039,10 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
 
     def compareCompiletimeAppliedType(tp: AppliedType, other: Type, fromBelow: Boolean): Boolean = {
       if (defn.isCompiletime_S(tp.tycon.typeSymbol)) compareS(tp, other, fromBelow)
-      else tp.tryCompiletimeConstantFold.exists(folded => recur(folded, other))
+      else {
+        val reduced = tp.tryCompiletimeConstantFold.getOrElse(tp.superType)
+        recur(reduced, other)
+      }
     }
 
     /** Like tp1 <:< tp2, but returns false immediately if we know that

tests/neg/singleton-ops.scala

@@ -6,6 +6,12 @@ object Test {
   summon[2 + 2 =:= 3] // error
   summon[29 * 31 =:= 900] // error
 
+  val a: Int + Int = 3
+  val c: 1 + Int = 2
+  val d: Int + 1 = 1
+  summon[Int + 1 =:= Int]
+  summon[1 + 1 =:= Int] // error
+
   val t0: 2 + 3 = 5
   val t1: 2 + 2 = 5 // error
   val t2: -1 + 1 = 0