[SPARK-3411] Improve load-balancing of concurrently-submitted drivers across workers

If the waiting driver array is too big, the drivers in it will be dispatched to the first worker we get(if it has enough resources), with or without the Randomization.

We should do randomization every time we dispatch a driver, in order to better balance drivers.
This just looks wrong or pointless to me.  Because `workers` is a HashSet, it's not ordered.  Logically, shuffling a Set (i.e., changing the order in which elements are added to the Set) just gets you the same Set back again.  I think that is also what actually happens with a HashSet: 
```
scala> import scala.util.Random
import scala.util.Random

scala> val aHashSet = scala.collection.mutable.HashSet(...)
aHashSet: scala.collection.mutable.HashSet[...] = Set(...)

scala> val shuffledSet = Random.shuffle(aHashSet)
shuffledSet: scala.collection.mutable.HashSet[...] = Set(...)

scala> { for (i <- 0 until aHashSet.size) yield aHashSet(i) == shuffledSet(i) }.forall(_ == true)
res0: Boolean = true
```
To actually accomplish the reordering, you need to convert to a Seq before doing the shuffling:
```scala
val shuffledWorkers = Random.shuffle(workers.toSeq)  // yields an ArrayBuffer
```

And I'll ask again, what is the point of including workers whose state is not `WorkerState.ALIVE` and going through the trouble of shuffling in these workers that will only be filtered out later?  I really think that what you want is:
```scala
val shuffledWorkers = Random.shuffle(workers.toSeq.filter(_.state == WorkerState.ALIVE))
```