Pass symbol as an argument instead of a block

Using Ruby’s `Symbol#to_proc` is considerably more concise than using block syntax. It’s also about 20% faster (see benchmarks below). `Symbol#to_proc` is already used in many places throughout the Rails codebase, but not everywhere. This patch makes the codebase more consistent and concise. In some cases, it reduces the number of lines of code. For example, in `railties/lib/rails/application/routes_reloader.rb`:

```ruby
def finalize!
  route_sets.each do |routes|
    routes.finalize!
  end
end
```

becomes:

```ruby
def finalize!
  route_sets.each(&:finalize!)
end
```

The net result is 30 fewer lines of code.

For those who don’t know the history, `Symbol#to_proc` was originally part of Active Support, before being merged into the Ruby language in version 1.9 (and back-ported to 1.8.7). The Active Support implementation was slightly slower than using a block but the C implementation in MRI is considerably faster.

##### Benchmark

```ruby
require 'benchmark/ips'

def block
  (1..100).map{|i| i.to_s}
end

def to_proc
  (1..100).map(&:to_s)
end

Benchmark.ips do |x|
  x.report('block')   { block   }
  x.report('to_proc') { to_proc }
end
```

###### Ruby 2.1.2p95

```
  block 46707.3 (±7.8%) i/s - 235768 in 5.079617s
to_proc 55143.5 (±7.2%) i/s - 276554 in 5.040752s
```

###### Ruby 2.0.0p481

```
  block 33271.0 (±6.8%) i/s - 168646 in 5.093196s
to_proc 37346.0 (±7.6%) i/s - 188870 in 5.087220s
```

###### Ruby 1.9.3p545

```
  block 31478.7 (±11.3%) i/s - 156876 in 5.056661s
to_proc 39219.9  (±7.2%) i/s - 195210 in 5.004236s
```