Better circular dependency handling

Better circular dependency handling so property injection ALWAYS works with circular dependencies and property injected classes are always properly injected prior to being passed to the constructor of a constructor injection. Hence you can have classes that use constructor injection that can use any instances with circular dependencies passed to them as long as they are using property injection.
It would be good to try to line this up with the _Preparing_/_Activating_/_Activated_ flow that constructs the graph of components.

Although there are cases that it's not ultimately flexible, the phases are somewhat explicable in terms like: preparing is before any activation takes place and prerequisite dependencies are gathered; activating is the phase where prerequisite dependencies (e.g. via ctor) have been filled and non-prerequisite dependencies are gathered; activated is where cycles between non-prerequisite dependencies are completed.

Like I said, it's not perfect, but it works in terms of a dependency graph and the operations made while constructing it. Properties themselves aren't a first-class concept at this level.

Is there a way to name/visualize this in terms of graph operations rather than the underlying instance's features? If so that might also help resolve some of the design points around how it fits in with `ReflectionActivator` and friends.

(Just in case it sounds a bit theoretical to approach it this way - it's not that uncommon to see components made up of multiple instances, though you sometimes need to squint to see how they work :))