feat: Don't run InteractiveDriver.run if the content didn't change

If the content didn't change since the last `driver.run`, do not compile
because the compilation unit should have the up to date typed tree.
Skip compilation save up much of CPU usage when users are reading
source code (and hover on symbols) without modifying the source code.

What happens if we change in a file affect another file's type
information?

For example, when we have the following source files, if we hover on
`B.foo` in `A.scala`, Metals shows the symbol's type is `Int`.

```scala
// A.scala
def main = println(B.foo)

// B.scala
object B:
  def foo: Int = ???
```

When we modify `B.scala` to `def foo: String = ???`, what happens to
`A.scala`?
You may think that, Metals keep using the old compilation
unit that shows `B.foo` as `Int` instead of `String` because Metals
invalidates the compilation cache based on its content hash.

That's not true, `alreadyCompiled("A.scala", <content hash>)` will be
`false`, and Metals will run `driver.run` on `A.scala` and show `String`
for `B.foo` in `A.scala`.

Why? Because Metals will recreate a new `MetalsDriver` and `lastCompiled`
cache will be cleared up.

- When a file has changed, Metals call [Compilers.restart](https://github.com/scalameta/metals/blob/c6e0f30febeff67e970e463d79862e27e45ada3f/metals/src/main/scala/scala/meta/internal/metals/Compilers.scala#L247).
- The restart method calls `shutdownCurrentCompiler` that [set `_compiler` to `null`.](https://github.com/scalameta/metals/blob/c6e0f30febeff67e970e463d79862e27e45ada3f/mtags/src/main/scala/scala/meta/internal/pc/CompilerAccess.scala#L57-L74).

This is basically the same way to cache compilation as Scala2
See my explanation on how Scala2 + Metals compilation cache works
https://contributors.scala-lang.org/t/how-does-scala2-compiler-cache-invalidate-the-typechecking-result-for-the-given-tree/5858/4?u=tanishiking

Author: tanishiking

mtags/src/main/scala-3/scala/meta/internal/pc/MetalsDriver.scala

@@ -0,0 +1,42 @@
+package scala.meta.internal.pc
+
+import java.net.URI
+
+import scala.collection.concurrent.TrieMap
+
+import scala.meta.internal.mtags.MD5
+
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.interactive.InteractiveDriver
+import dotty.tools.dotc.interactive.SourceTree
+import dotty.tools.dotc.reporting.Diagnostic
+import dotty.tools.dotc.util.SourceFile
+
+class MetalsDriver(
+    override val settings: List[String]
+) extends InteractiveDriver(settings):
+
+  private val lastCompiled: TrieMap[URI, String] = TrieMap.empty
+
+  private def alreadyCompiled(uri: URI, hash: String): Boolean =
+    lastCompiled
+      .get(uri)
+      .map(cache => cache == hash)
+      .getOrElse(false)
+
+  override def run(uri: URI, source: SourceFile): List[Diagnostic] =
+    val content = source.content.mkString
+    val contentHash = MD5.compute(content)
+    if alreadyCompiled(uri, contentHash) then Nil
+    else
+      lastCompiled.put(uri, contentHash)
+      super.run(uri, source)
+
+  override def run(uri: URI, sourceCode: String): List[Diagnostic] =
+    val contentHash = MD5.compute(sourceCode)
+    if alreadyCompiled(uri, contentHash) then Nil
+    else
+      lastCompiled.put(uri, contentHash)
+      super.run(uri, sourceCode)
+
+end MetalsDriver

mtags/src/main/scala-3/scala/meta/internal/pc/Scala3CompilerAccess.scala

@@ -24,7 +24,7 @@ class Scala3CompilerAccess(
     sh: Option[ScheduledExecutorService],
     newCompiler: () => Scala3CompilerWrapper,
 )(using ec: ExecutionContextExecutor)
-    extends CompilerAccess[StoreReporter, InteractiveDriver](
+    extends CompilerAccess[StoreReporter, MetalsDriver](
       config,
       sh,
       newCompiler,

mtags/src/main/scala-3/scala/meta/internal/pc/Scala3CompilerWrapper.scala

@@ -7,10 +7,10 @@ import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.interactive.InteractiveDriver
 import dotty.tools.dotc.reporting.StoreReporter
 
-class Scala3CompilerWrapper(driver: InteractiveDriver)
-    extends CompilerWrapper[StoreReporter, InteractiveDriver]:
+class Scala3CompilerWrapper(driver: MetalsDriver)
+    extends CompilerWrapper[StoreReporter, MetalsDriver]:
 
-  override def compiler(): InteractiveDriver = driver
+  override def compiler(): MetalsDriver = driver
 
   override def resetReporter(): Unit =
     val ctx = driver.currentCtx

mtags/src/main/scala-3/scala/meta/internal/pc/ScalaPresentationCompiler.scala

@@ -54,7 +54,7 @@ case class ScalaPresentationCompiler(
   private val forbiddenOptions = Set("-print-lines", "-print-tasty")
   private val forbiddenDoubleOptions = Set("-release")
 
-  val compilerAccess: CompilerAccess[StoreReporter, InteractiveDriver] =
+  val compilerAccess: CompilerAccess[StoreReporter, MetalsDriver] =
     Scala3CompilerAccess(
       config,
       sh,
@@ -70,7 +70,7 @@ case class ScalaPresentationCompiler(
       case head :: tail => head :: removeDoubleOptions(tail)
       case Nil => options
 
-  def newDriver: InteractiveDriver =
+  def newDriver: MetalsDriver =
     val implicitSuggestionTimeout = List("-Ximport-suggestion-timeout", "0")
     val defaultFlags = List("-color:never")
     val filteredOptions = removeDoubleOptions(
@@ -81,7 +81,7 @@ case class ScalaPresentationCompiler(
         .mkString(
           File.pathSeparator
         ) :: Nil
-    new InteractiveDriver(settings)
+    new MetalsDriver(settings)
 
   override def getTasty(
       targetUri: URI,