Expression syntax should properly handle chained expressions like `a <= expr <= b`
I don't know that we're able to do this, actually:

```python
In [1]: class Expr(object):
   ...:     def __init__(self, lhs, op, rhs):
   ...:         self.lhs, self.op, self.rhs = lhs, op, rhs
   ...:     def __str__(self):
   ...:         return '%s %s %s' % (self.lhs, self.op, self.rhs)
   ...:     def __le__(self, other):
   ...:         return Expr(self, '<=', other)
   ...:     def __ge__(self, other):
   ...:         return Expr(self, '>=', other)
   ...: 

In [2]: e = Expr(None, None, None)

In [3]: print(2 <= e <= 5)
None None None <= 5
```

See how the first comparison (2 <= e) is lost?

The best you can get is to use parentheses, but the semantics change and will not be correct:

```python
In [5]: print((2 <= e) <= 5)
None None None >= 2 <= 5
```

Anyways, you should probably be using `.between()` anyways, as some databases are able to optimize this:

```python
M.select(M.id).where(M.id.between(2, 3))
```
 Indeed, this is impossible to implement in Python. I'm surprised.

```
>>> dis.disassemble((lambda: x <= y < z).__code__)
  1           0 LOAD_GLOBAL              0 (x)
              2 LOAD_GLOBAL              1 (y)
              4 DUP_TOP
              6 ROT_THREE
              8 COMPARE_OP               1 (<=)
             10 JUMP_IF_FALSE_OR_POP     9 (to 18)
             12 LOAD_GLOBAL              2 (z)
             14 COMPARE_OP               0 (<)
             16 RETURN_VALUE
        >>   18 ROT_TWO
             20 POP_TOP
             22 RETURN_VALUE
```

The result of one of the comparisons will always be ignored (8 -> 10 -> 18 => second comparison never executed; or 8 -> 10 -> 12 => result of first comparison is dropped). Thank you for your comment Jonas, very nice debugging and a better explanation than the one I provided.
IMO Peewee should support chained expressions like `a <= expr <= b` or raise an error.

```py
# M = my model.
# As expected, there are 3 objects with id <= 3.
In [33]: list(M.select(M.id).where(M.id <= 3).tuples())
Out[33]: [(1,), (2,), (3,)]

# Unexpected: Ignores the first constraint.
In [34]: list(M.select(M.id).where(2 <= M.id <= 3).tuples())
Out[34]: [(1,), (2,), (3,)]
```