Allow disabling lazy loading
Here are a couple ideas:

* Use the `<fk field>_id` accessor -- this will return the value of the foreign key column w/o triggering a lookup on the related table.
* Subclass `ForeignKeyField` and override the `_get_descriptor()` method to return a descriptor w/the desired behavior Thanks, I'll try those out! FYI for anyone wondering about the same: I decided to just use option 1 (using `<fk field>_id` as accessor).

Implementing custom `RelationDescriptor` (option 2) is easy, but it becomes confusing what the field should return:

```python
a = Foo.create()
b = Foo.create(parent=a)

b.parent  # has a instance in object cache so returns a's Foo() instance
b.parent.id  # works

b2 = Foo.get(id=b.id)

b2.parent  # only has PK and parent instance is not cached so should it return int or throw error or what...? if it returns int then:
b2.parent.id  # fails to exception
```

If I made descriptor always return raw PK value, that would be less confusing, but then doing something like `a.parent.id` would not be possible, even if `a` had parent instance already cached. So, going to use use `<fk field>_id` accessors for now.
Is it possible to disable lazy loading of foreign keys somehow? I assume the magic happens in some `__getattr__` or proxy class but not sure where.

You probably don't want to add this as a built-in option, but if you have any pointers to what I should stab, that would be nice.

Use case: I am tuning my code for performance and wouldn't like peewee to do any queries that I didn't intend. I have some quite large fields in DB that I don't want to accidentally load.