Separate expression parsing and rendering from Context#[]

@Shopify/liquid for review

## Problem

The Liquid::Variable class doesn't actually parse the variable expression during the parse phase.  Instead it just separates a `@name` string from the filters, then the `Context#[]` method is used to parse and evaluate the `@name` expression string.

## Solution

I used the variable cache that @jasonhl added to the Context class, and extended it to cache the whole expression parsing that `Context#[]` does, which includes literals as well as variable lookups.  The Expression.parse will return a RangeLookup or VariableLookup object when it needs to be lazily evaluated, otherwise it returns an eagerly evaluated literal value that can be used directly during rendering.

## Benchmarks

Before:

```
dylansmith:~/src/liquid(master)$ bundle exec rake benchmark:run
/Users/dylansmith/.rbenv/versions/2.1.2/bin/ruby ./performance/benchmark.rb lax
Rehearsal ------------------------------------------------
parse:         3.460000   0.010000   3.470000 (  3.474560)
parse & run:   7.590000   0.000000   7.590000 (  7.595347)
-------------------------------------- total: 11.060000sec

                   user     system      total        real
parse:         3.440000   0.020000   3.460000 (  3.454311)
parse & run:   7.520000   0.020000   7.540000 (  7.540219)
```

After:

```
dylansmith:~/src/liquid(extract-context-parse)$ bundle exec rake benchmark:run
/Users/dylansmith/.rbenv/versions/2.1.2/bin/ruby ./performance/benchmark.rb lax
Rehearsal ------------------------------------------------
parse:         3.430000   0.020000   3.450000 (  3.449185)
parse & run:   7.300000   0.010000   7.310000 (  7.318799)
-------------------------------------- total: 10.760000sec

                   user     system      total        real
parse:         3.410000   0.010000   3.420000 (  3.421339)
parse & run:   7.300000   0.010000   7.310000 (  7.316055)
```

almost a 3% speedup.

Object profile before:

```
dylansmith:~/src/liquid(master)$ bundle exec rake profile:run
Profiling in object mode...
==================================
  Mode: object(1)
  Samples: 7282900 (0.00% miss rate)
  GC: 0 (0.00%)
==================================
     TOTAL    (pct)     SAMPLES    (pct)     FRAME
   2022100  (27.8%)     1299000  (17.8%)     Liquid::Variable#lax_parse
    723100   (9.9%)      723100   (9.9%)     block in Liquid::Variable#lax_parse
    625200   (8.6%)      625200   (8.6%)     Liquid::Context#variable_parse
   2856100  (39.2%)      597000   (8.2%)     Liquid::Block#create_variable
   9025500 (123.9%)      474300   (6.5%)     Liquid::Block#parse
    438600   (6.0%)      438600   (6.0%)     Liquid::Template#tokenize
   1282700  (17.6%)      421100   (5.8%)     Liquid::Context#resolve
   2178900  (29.9%)      300600   (4.1%)     Liquid::Variable#render
   1046400  (14.4%)      295500   (4.1%)     block in Liquid::Variable#render
    289100   (4.0%)      289100   (4.0%)     Liquid::If#lax_parse
   2259100  (31.0%)      238800   (3.3%)     block in Liquid::Block#create_variable
    204800   (2.8%)      204800   (2.8%)     Liquid::StandardFilters#truncatewords
    146100   (2.0%)      143500   (2.0%)     Liquid::For#lax_parse
    131300   (1.8%)      131300   (1.8%)     block in Liquid::Context#variable
   5942800  (81.6%)      108700   (1.5%)     Liquid::Block#render_all
    600600   (8.2%)       98500   (1.4%)     Liquid::Context#invoke
     66300   (0.9%)       66000   (0.9%)     Liquid::Context#initialize
    683300   (9.4%)       58100   (0.8%)     block in Liquid::Context#initialize
     53000   (0.7%)       53000   (0.7%)     Liquid::Block#initialize
   9648200 (132.5%)       47600   (0.7%)     Liquid::Tag.parse
```

Object profile after:

```
dylansmith:~/src/liquid(extract-context-parse)$ bundle exec rake profile:run
Profiling in object mode...
==================================
  Mode: object(1)
  Samples: 7067400 (0.00% miss rate)
  GC: 0 (0.00%)
==================================
     TOTAL    (pct)     SAMPLES    (pct)     FRAME
   2022100  (28.6%)     1299000  (18.4%)     Liquid::Variable#lax_parse
    723100  (10.2%)      723100  (10.2%)     block in Liquid::Variable#lax_parse
   2856100  (40.4%)      597000   (8.4%)     Liquid::Block#create_variable
    559700   (7.9%)      559700   (7.9%)     Liquid::VariableLookup#initialize
   9025500 (127.7%)      474300   (6.7%)     Liquid::Block#parse
    438600   (6.2%)      438600   (6.2%)     Liquid::Template#tokenize
   2000500  (28.3%)      300600   (4.3%)     Liquid::Variable#render
   1018600  (14.4%)      295500   (4.2%)     block in Liquid::Variable#render
    289100   (4.1%)      289100   (4.1%)     Liquid::If#lax_parse
    895100  (12.7%)      269900   (3.8%)     Liquid::Context.parse
   2259100  (32.0%)      238800   (3.4%)     block in Liquid::Block#create_variable
    204800   (2.9%)      204800   (2.9%)     Liquid::StandardFilters#truncatewords
    146100   (2.1%)      143500   (2.0%)     Liquid::For#lax_parse
   5250500  (74.3%)      108700   (1.5%)     Liquid::Block#render_all
    999800  (14.1%)      104700   (1.5%)     block in Liquid::Context#initialize
    600600   (8.5%)       98500   (1.4%)     Liquid::Context#invoke
     66300   (0.9%)       66000   (0.9%)     Liquid::Context#initialize
    625200   (8.8%)       65500   (0.9%)     Liquid::VariableLookup.parse
     53000   (0.7%)       53000   (0.7%)     Liquid::Block#initialize
   9648200 (136.5%)       47600   (0.7%)     Liquid::Tag.parse
```

almost a 3% reduction in object allocation.

## To Do

`Context#[]` is used in a number of tags to looking up variables used in the markup.  These tags should use Expression.parse during parsing then Context#evaluate during rendering, after which we can remove the `@parsed_expression` cache variable in the Context class.  This should speed up strict parsing which is currently parsing the expressions during the parse phase for validation then just returning the original expression string to use with `Context#[]` during rendering.
I don't think we need caching once we actually move all the parsing out of rendering phase, since previously we would re-parse the same markup when it is within a loop block.  We were previously caching the variable lookup itself, and moving the caching to the expression hasn't caused a regression.