filter_column - versatile filtering method

Hi, this is my first pull request so please be forgiving.

filter_column is an aproach to more versatile filtering than just LIKE %...%.
This function uses QueryBuilder's builtin functions by simply passing all parameters to the choosen QueryBuilder method.

# The syntax:
`filter_column ( $column_name,  $method,  $param_1, $param_2  ...  $param_n  )`

Tips:
* `$column_name` - the column name that search filter is be applied to
* `$method` - can be any of QueryBuilder methods (where, whereIn, whereBetween, having etc.). 
  * Note: For global search these methods are automaticaly converted to their "or" equivalents (if applicable, if not applicable, the column is not searched).
  * If you do not want some column to be searchable in global search set the last where's parameter to "and" (see line 17 in example above). Doing this way the filter cannot be switched into its "or" equivalent therefore will not be searched in global search .
* `$param_1 ... $param_n` -  these are parameters that will be passed to the selected where function. Possible types:
  * `string`
  * `DB::raw()` - The DB::raw() can output literaly everything into the query, for example subqueries or branching if you need some really sophisticated wheres.
  * `function` - or any other callable
  * `array` of any above
* the search value is passed to the query by `$1` string placed anywhere in parameters. If callable (function) is used the searched value is passed to callable as first parameter. The callable must returns value that will be passed to the QueryBuilder's function.

# Examples:

In my projects I often use filtering/searching on datatables, so I need more universal aproach of filtering the query results. For example if i need to search for an "Order" with "id = 123" i would like to see only **one** order as a result, **not** every result that has "123" in it's id (like 1234, 5123, 1230 etc.)
This can be made like this:

## simple search

searching for value: `123`

code:
```php
$posts= Post::select(array('id','name','content'));
return Datatables::of($orders)
  ->filter_column('id', 'where', 'id', '=', '$1')
  ->make();
```

this translates to QueryBuilder's `where ('id', '=', 123)`
so the result SQL is `WHERE id = 123`


Often the data you want to search for must be somehow prepared. You can use DB::raw() to do this.
The DB::raw() can output literaly everything into the query, for example **subqueries** or **branching** if you need some really sophisticated wheres.

## simple use of DB:raw()

searching for value: `FOo`
code:
```php
$books= Book::select(array('id','code','name'));
return Datatables::of($books)
  ->filter_column('code', 'where', 'code', '=', DB::raw('UPPER($1)'))
  ->make();
```

this translates to QueryBuilder's `where ('code', '=', DB::raw('UPPER($1)'))`
so the result SQL is `WHERE code = UPPER("FOo")`


Some QueryBuilder methods need an array as parameter, this can be done using inline function.
Also if you need do some more complicated input data filtering / parsing this can be done inside function and then returned into search query.

## using callable

searching for value: `Cat,Dog,Elephant`

code:
```php
$friends = Friend::left_join('pets','friend.pets_id','=','pets.id')->select(array('friend.id','friend.name','pets.name as petsName'));

return Datatables::of($friends)
  ->filter_column('petsName', 'whereIn', 'pets.name', function($value) { return explode(',',$value); })
  ->make();
```

this translates to QueryBuilder's `whereIn ('pets.name', array( 'Cat', 'Dog', 'Elephant' ) )`
so the result SQL is `WHERE pets.name IN  = ( "Cat", "Dog", "Elephant" ) `