Size of standard library and possible tricks to reduce its size

So, the library jar is getting kinda bulky, especially after the addition of parallel collections. I've been noticing that there's a whole lot of repetitive trait-stub instantiations -- scala/collection/Iterator$$anon$* are great examples of these (they're all different subtypes of Iterator itself) -- and I wonder if anyone has thought to create some library-private abstract classes to flatten some of the bytecode bloat.
For instance, my personal library has the following tree of private-use types tucked away in a package object. You'll note that they are basically a parallel to the corresponding traits, inheriting from the largest abstract superclass available "with" the more specific trait.
Effectively, these let me create multiple custom subtypes of the corresponding traits, but the swath of trait stubs are only compiled to bytecode exactly once (at the abstract class level). So instead of consuming 21k of bytecode for every subtype of Iterator that I need, it only takes about 1k each. I get similar savings from the other classes in the tree.
These abstract classes for my use take up ~240k of classfile space with 2.9.1, but that hit is only taken once, not upon creation of every subtype. This saves a pretty significant chunk of bytecode, and the same trick would likely work well in the standard library. Thoughts?
package object collection {  import scala.collection._
  private[collection] abstract class AbstractTraversableOnce[T]    extends TraversableOnce[T]
  private[collection] abstract class AbstractTraversable[T]    extends AbstractTraversableOnce[T] with Traversable[T]
  private[collection] abstract class AbstractTraversableProxy[T]    extends AbstractTraversable[T] with TraversableProxy[T]
  private[collection] abstract class AbstractIterable[T]    extends AbstractTraversable[T] with Iterable[T]
  private[collection] abstract class AbstractIterableProxy[T]    extends AbstractIterable[T] with IterableProxy[T]
  private[collection] abstract class AbstractIterator[T]    extends AbstractTraversableOnce[T] with Iterator[T]
  private[collection] abstract class AbstractMap[A, B]    extends AbstractIterable[(A, B)] with Map[A, B]
  private[collection] abstract class AbstractMapProxy[A, B]    extends AbstractMap[A, B] with MapProxy[A, B]
  private[collection] abstract class AbstractSeq[T]    extends AbstractIterable[T] with Seq[T]
  private[collection] abstract class AbstractSeqProxy[T]    extends AbstractSeq[T] with SeqProxy[T]
  private[collection] abstract class AbstractSet[T]    extends AbstractIterable[T] with Set[T]
  private[collection] abstract class AbstractSetProxy[T]    extends AbstractSet[T] with SetProxy[T]}