DeferredManyToManyField
As you noticed, there's no such thing as a `DeferredManyToManyField`, nor do I think there needs to be. Remember that a many-to-many is just a junction table with foreign-keys to the table(s) being related via many-to-many. To use my favorite example,

```python

class Student(Model):
    name = TextField()
    # courses = ManyToManyField(Course) ??? there's no need to do this.

class Course(Model):
    name = TextField()
    students = ManyToManyField(Student)  # do this instead. many-to-many is symmetrical.

# Or, better yet, don't use ManyToManyField at all and just:
class CourseStudent(Model):
    course = ForeignKeyField(Course)
    student = ForeignKeyField(Student)
```

> I wonder if it'd possible to add a `through_model` keyword to both `ForeignKeyField` and `DeferredForeignKey` which, if set, would make the foreign key behave as a `ManyToManyField`.

Zen of Python:

> Special cases aren't special enough to break the rules.
> ...
> There should be one-- and preferably only one --obvious way to do it. 
I hit a case in which I'd have liked to be able to use a `DeferredManyToManyField` with a `DeferredThroughModel`. In my case I was able to fix it rearranging the order of the model classes so that the `ManyToManyField` would not need to point to a deferred model, but I wonder if that will always be the case.

Ultimately, and to make things a bit cleaner, I wonder if it'd possible to add a `through_model` keyword to both `ForeignKeyField` and `DeferredForeignKey` which, if set, would make the foreign key behave as a `ManyToManyField`.