A CollectionFixture seems the right way to start and stop the redis server
for the tests, but they are not working in Xunit at the moment so this is the
next best thing. Have added a RedisXunitTestExecutor which starts the
server in its constructor and stops it in the destructor (unfortunately
had to use that because Dispose() wasn't always called).

Also found that you _must_ have only one ConnectionMultiplexer per set of
config options - more causes multi-threading issues which means the tests
sometimes work but more often fail. So set up a static Dictionary of
config options to ConnectionMultiplexer in RedisDatabase and only create
the ConnectionMultiplexer as needed.

The Simple Tests are now running with server starting and stopping as
expected both under VS and for k test - so re-enabling the latter.
Fixed a couple of issues with tests when running with no existing databases:
- Temporary code in F1Context.CreateModel calls AddProperty which replaces an existing property with a new one, without updating the keys. That causes issues when we order properties in the DatabaseBuilder and rely on reference equality, resulting in duplicate columns. The fix is to move the code at the begining of the method so they don't get recreated.
- File not found exception about Northwind.sql because specified relative path goes up one directory too much.
Paul Daniels or Penn & Teller? (Remove relationship APIs from BasicModelBuilder)

We decided last week that we should have a basic model builder that would map closely to the underlying metadata and would not use any conventions together with the more traditional model builder that has sugar API and makes use of conventions. The relationship APIs (OneToMany, OneToOne, etc.) cannot function without conventions and so should live only on the convention-based builder. In doing this the inheritance, overrides, and "new" classes and methods became increasingly difficult to handle, so most of this change is a refactoring  which hopefully makes things easier to handle and evolve.

Some possible approaches I looked into were:
- Deriving the convention builder from the basic builder. This didn't work very well because of the need for changing of types in the sub-builders, resulting in a lot of "new" methods. It also means we can add things to the convention API, but cannot remove things. For example, currently the convention API has both the sugar relationship APIs and the lower-level ForeignKey API, but we may choose to not expose the ForeignKey API.
- Also, we currently derive the generic builders from the non-generic builders. This works quite well, although the need for a base class makes it harder to work with, and this leaks into the code for extension methods which have quite involved generic type definitions using the base types.

The best approach I have been able to come up with makes use of a couple of patterns that have worked well in the past:
- Split the actual logic of model building into implementation classes. These are not specific to the convention or basic builders which can then make use of any functionality that makes sense. This allows the public API to be decoupled from the implementation so that we can present the public API that we want while keeping the logic in a single place and factored appropriately for the implementation. Traditionally these implementations would have been internal, but I have made them public in keeping with the EF7 philosophy, just in an internal namespace.
- The actual basic and convention builders are now separate and don't derive from each other. This does result in some code duplication, but it is specifically API code and not implementation code, and it allows for flexibility in the two APIs as described above.
- Conversion operators between the two types of builders are easy to create and I added them at the top-level, but we should discuss whether these are really useful.
- I wanted to make API extensions relatively easy to write and also allow a single extension to be used for both the basic and conventional builders. To facilitate this there are interfaces for each of the builders that can be targeted by extension methods. These interfaces provide easy access to the metadata item being targeted (e.g. EntityType), the model, and the Annotation API. This allows extensions to be written in a very similar way to the core fluent API. It does not provide direct access to all the fluent methods of the builders because doing so tends to make the interface/type definitions overly complex. Also, the fluent methods available are different for the different builders. If the fluent methods need to be used it is still possible to write specific extension methods for specific builders.