This fixes the issue causing the collector to miss instances.

Problem

The problem was that we'd scan package X, then check if there are any unprocessed instances in the X package instance set before moving to the next package. However, with generics, package X could contain Foo[T any] that isn't instantiated anywhere within package X, then package Y could call Foo[int] causing the X package instance set to have an unprocessed instance in it. Foo[int] would never be processed because we had moved onto package Y.

This wouldn't be a problem for Foo[int] because it still got into the instance set for X. However, if inside of Foo[T] was the instantiation Bar[T] and Bar[T] isn't instantiated anywhere else, then we'd have to process Foo[int] to discover the instance Bar[int]. Since Foo[int] would never be processed, Bar[int] would be missing.

This is caused by how generics can invert dependencies. We process packages based on import order, but with generics, package Y could import X and therefore is scanned after X, however Y could create instances in X, thus inverting the dependencies because X now depends on instance information defined in Y.

Fix

To fix this problem I moved all the processing of unprocessed instances until after all packages were scanned. The processing is allowed to recheck packages multiple times until every instance added before and added during processing has been processed (e.g. If Bar[T] used Baz[T] then Foo[int] being processed would add Bar[int] that would need to be processed to get Baz[int] and so on).

I also fixed some spelling and some odd spacing in the code.

This is related to #1013 and #1270