Created `mongo { ... }` query expression.

Defines a custom `where` operator for handling predicates, i.e. the
filter on the MongoCollection.Find member.

Intended as a computation expression implementation of the Fluent API.
Handle nested `where` operators by replacement.

Overrides the previous filter with the new one. An alternative approach
that is taken by query expressions, i.e. query { ... } in F#, (at least
for sequences, possibly not for IQueryable) is to **and** the filters
together.
Made IMongoCollection inherit sequence type.

This way collections can be used in `for ... in` expressions.
Made quotation parsing function available to other modules.

Changed access control from private to internal.
Fixed issue with unsugared, op_Dynamic (?) in quotations.

Need to handle expressions that are coerced to a particular type, e.g.
the result type must be an integer to use the increment operation.

Also had an issue where the active pattern CallDynamic is a superset of
the GetProperty pattern, when should only allowed to be changed.
Extended support for typed collections and update operations.

Note that in F# 3.0, the type inference system requires an annotation
on the document when used by other members in the computation
expression, regardless of that fact it maintains the variable space.
This appears to have been resolved in F# 3.1 (see the Visual Studio F#
Team Blog).

The return type of the MongoQueryBuilder will be changed to
MongoOperationResult, which will either return a Scope type or actually
execute the operation specified (depending on query/update/etc.).
Added `defer` custom operator to mongo { ... } workflow.

Returns a union type containing BsonDocument(s) for the query and
update operations that were specified in the computation expression.

Enables the testing of recognition for the various MongoDB operators
without the need to connect to the database and actually execute.
Wrote tests and defined type signatures for update operations.

Still need to figure out specification of array modifiers, i.e. $each,
$slice, and $sort.
Added support for $unset operator in mongo expression.

Needs to create a code quotation of `NewUnionCase (None)`. Uses
reflection on the option type to get the union case.

Currently does not enforce that the field resolves to an option type,
as is done with the typed code quotations, but easily could by changing
the type signature to 'a -> 'b option.
Extended support for transforming update operations.

Changed design, so rather than convert to the format recognized by the
existing code quotation parsers, simply constuct the BsonElements here.
This was done due to some complications with the type validation that
goes on with the variables and expressions, especially with the `|>`
(forward-pipe) operator.

Instead, there is now a ``fake'' parser that you can partially apply
the resulting BsonElement to, and still accepts the var, field, and
expression parameters for consistency with the existing structure.
Added support for $each and $slice operators in mongo expression.

Defined two separate custom operators: `pushEach` and `addToSetEach`
for combination with $push and $addToSet respectively.

In order to enforce that the `slice` custom operator is only used
(immediately) after a `xxxEach` operator, a new interface that extends
from IMongoUpdatable was defined.

Note that similar to the other operations in the Fluent Spec, the last
assigned value is the one that is used, e.g. with

    mongo {
        for x in clctn do
        update
        pushEach x?tags [ "appliances"; "school"; "book" ]
        slice -4
        slice -2
    }

the `tags` field will contain only the last **two** elements.
Added support for $sort operator in mongo expression.

Defined the following custom operators:
  - `sortListBy`
  - `sortListByDescending`
  - `thenListBy`
  - `thenListByDescending`

Takes as its first parameter, a list property to refer to the scope of
the array; and as its second parameter, a field property to sort on.
Note that the first should be validated against the first parameter to
the `pushEach` operation.
Moved all $push operations onto a single line.

Seems to be the style we are going with right now.
Wrote tests for unsugared forms of code quotations.

Verifies correction from @f9dfb77.
Begin support for extracting collection or scope from loop.

Only matches on the PropertyGet pattern, which is how the values are
represented when defined as bindings in a module.
Fixed issue where was not traversing the continuation on updates.

As previously written, the MongoBuilder.Update member was essentially
treated as a terminal node in the AST, which would causes the
IMongoCollection/Scope in the for loop to not be extracted for update
operations.

Added a no-op case to recognize the member.
Removed type annotation from mongo expressions.

Figured out that the reason the type was unknown in the custom
operators is because the return type of the MongoBuilder.For member
was a fresh generic, and not IMongoQueryable<'a>.
Added support for collection/scope defined in function.

Within the quotation for the computation expression, a collection
defined on the module is represented as a static member, and hence
recognized by the PropertyGet active pattern, whereas within another
let definition, is embedded directly as its Value.

Refer to http://stackoverflow.com/questions/18413138.
Defined mongo { ... } computation expression.

Able to build query and update documents using the `defer` custom
operation. Otherwise, the query form creates a `Scope<'DocType>`
instance, and the update form executes the operation and returns the
`WriteConcernResult`.

Added license information to header of new files.