proposal on QueryCompiler._parse()
I'm not sure I agree with this proposal.  The "cost" of evaluating a SQL expression only occurs once, when the SQL is generated and handed off to the cursor, so I'm not sure I see the need to refactor this for performance.  Additionally `isinstance()` is more flexible than calling `type()` because it understands derived classes.

You have very long if-elif-elif-...else in QueryCompiler._parse(), where it mostly works with sql, params..
It would be better to use this something like this construction:

```
 def non_inline_function(a,b,c):
     # do some /1
     # do some /2
     # do some /3
     return ('sql', 'pqrams')

 mapper = {
     Func: lambda a,b,c: (func_A(a,b), func_B(c)) # very simple, inline
     Clause: non_inline_function # not simple, defined above
     Param: ... # etc
 } # or, may be some variant with closure

def parse(node, alias_map, conv):
    try:
       sql, params = mapper[type(node)](node, alias_map, conv)        
    except KeyError:
        # other more common or more complicated situations
        pass
```

So peewee will not loop over all ef-elif-elif-.. and will use "cached" lambdas (or even not lambdas).
It would be speed-up (may be not big, but.. speed-up) with cost of readability (it is possible to make it even more readable).

Right now this function is actually dispatches conversions depending on node type, so why not to make it in more traditional way?
