0.4.0 Release

## What's new:

### db.AttachAndModify(item).Set(x => x.Property, "NewValue") 
A simpler API for working with disconnected entities and only updating single values. This is useful if you want to update a value on an entity without roundtripping the database. A typical usecase could be to update the number of reads of a blogpost. With this API it would look like this
```
using (var db = Context.Sql())
 {
      db.AttachAndModify(new BlogPost { ID = postId }).Set(x => x.Reads, 10);
      db.SaveChanges();
}
```
The Set method is chainable so you could fluently add more properties to update.

This would send this single command to the database:
```
exec sp_executesql N'UPDATE [dbo].[BlogPosts]
SET [Reads] = @0
WHERE ([ID] = @1)
',N'@0 int,@1 int',@0=10,@1=1
```
### db.Database.ForceDelete() 
Drops the mssql database even if it has connections open. Solves the problem when you are recreating the database in your tests and Management Studio has an open connection that earlier prevented dropping the database.

### IncludeEFU

Relating to my post http://mikee.se/Archive.aspx/Details/entity_framework_pitfalls,_include_20140101 this tries to solve the problem with original Include performance in a developer friendly way. 

It will load every Included collection as a separate query instead and then manually fix the relations. The goal is also to provide child collection filtering, sorting and if possible paging. 

The goal is to make the API look like this:

```
var result = db.Contacts
.IncludeEFU(c => c.PhoneNumbers)
.IncludeEFU(c => c.Emails)
.Where(c => !c.FirstName.Contains("3"))
.OrderByDescending(c => c.FirstName)
.ToList();
```
It should not matter if you place the Where() and OrderBy() on the root entity before or after the includes.

To filter and sort child collection the goal is to get something like

```
var result = db.Contacts
.IncludeEFU(c => c.PhoneNumbers.Where(p => !p.IsPrivate).OrderBy(p => p.Number))
.ToList();
```

#### Notes
This will be implented by wrapping the QueryProvider. This is done by EFUQueryable<T> and EFUQueryProvider<T> if anyone is interested in the implementation or even better is interested in giving feedback on how to build it better. How this works with other wrappers is a question for another day.

It will run all queries AsNoTracking(), even the root query. Remember this is about performance when loading many entities for ReadOnly scenarios.   

It will not work with composite keys in the first iteration unless someone help me add that support. 

The name of the Method will change to something that better describes what it does if I figure something out. 

### Current status

ForceDelete is implemented. Possibly I'm looking at adding a ForceRecreate which drops the DB if it exists and then Creates a new one.

IncludeEFU is implemented in a first version which does not allow child collection filtering and also doesn't include filtering of the loaded child collections based on the filtering of the parent collection. I'm debating if I should load children using an IN clause or rewrite the expression for the root and apply it to the child collections.

I also need to find a way to get the DBContext from the orginal query. Right now the API looks like this

 ```
var result = db.Contacts
.IncludeEFU(db, c => c.PhoneNumbers)
.ToList();
```
Instead of what I want which is
 ```
var result = db.Contacts
.IncludeEFU(c => c.PhoneNumbers)
.ToList();
```
##### UPDATE 

Childcollections are now filtered using the same Where clause(s) as the the root collection. 

In my tests on real data this is significantly faster than the orginal Include() (4-6x on my dataset) but slightly slower than the code where I did it manually which is expected considering the amount of metadata/reflection programming needed to get this to work.

##### UPDATE

Childcollections can now be sorted and filtered. Example

```
var result = db.Contacts
.IncludeEFU(db, x => x.PhoneNumbers
    .Where(n => n.Number == "10134")
    .OrderBy(p => p.ContactId)
    .ThenByDescending(p => p.Number))
.ToList();
```

##### UPDATE

The loading of child collections now respects .Skip, .Take , .First and similar methods on the parent collection. That means if I do a .Take(20) on the parent collection only child items for those 20 parents will be loaded