Is `ReadOnlyPropertyAssertion` actually the most appropriate name?

I know that this was the name I wrote in the example code I provided for #81 , but when you start to think about it, it's actually not particularly accurate. It's not your fault (it's mine), but before releasing these classes to the public, we should make sure we get the naming correct; once we've released these classes, it would be a breaking change to rename them.

There are, AFAICT, at least two problems with the name *ReadOnlyPropertyAssertion*.

**It's not only about properties**

While this assertion verifies that there's a proper correspondence between a constructor argument and a property, it should also verify the equivalent for a public *field*.

**It's not only about read-only members**

Actually, I think the interesting part of this assertion is to verify that there's a proper connection between a constructor argument and a corresponding property or field. Often, these will be read-only, but they don't have to.

Consider, as an example, this class:

```c#
public class Foo
{
    public Foo(string bar)
    {
        this.Bar = bar;
    }

    public string Bar { get; set; }
}
```

Before the arrival of object initializers in C#, this was a common construct, because it enabled you to conveniently create an instance and supply important values in a single statement. Even though we now have object initializers in C#, the above construct is meaningful, and we should support it.

**What to call it, then?**

If we don't call it *ReadOnlyPropertyAssertion*, then what do we call it?

While I do have some thoughts on this, none of them are *particularly* good, so I'd love to hear other people's thoughts on this before I pollute your brains with my own, not-particularly-good ideas.