Blocks become more useful

HAML (and all the other template manager I've seen) have a big lack: blocks. Using a block should be more straightforward, and as a user, given this context:
```ruby
class Context
  def em
    '<em>#{yield}</em>'
  end
end
```

I expect this code:
```haml
Hello
= em do
   World
!!
```

To produce something like:
```html
Hello
<em>World</em>
!!
```

And not:
```html
Hello
World
<em>Hello
World</em>
!!
```

Yes, I know, for case like this we can use `capture_haml`, but this approach is really bad and cause a lot of issues. For example, if I use a [ViewModel](https://github.com/apotonick/cells) and want to use some pretty nice rails gem like `simple_form_for`, the only way is to clobber the actual context with all the method needed. However, if blocks work as expected, I could use the main `ActionView` object just like an helper container.
This is just some case, but I'm sure fixing this will give a lot more flexibility, plus I can't imagine a method that needs a block but doesn't use its content.

Hence, I've made this patch. If you like it, we could also *eradicate* a lot of helper method that become futile, and replace all the `capture_haml` with just a `yield` and `=`. I think this should also speed up the compiled code.

**There's only 2 test that I've skipped because I don't think they are really useful and it's quite hard to green them maintaining the same HAML source** (the same result can be achieved with a small modification of it).

Hope you find this as useful as I do :)
This won’t work in a couple of different situations. A line may happen to match this regex when it shouldn’t, which will resuly in the block being captured when it shouldn’t. e.g. this won’t produce any output:

```haml
- %w(capture the flag).each do |w|
  = w
```

The other situation is when `haml_capture` is called from within a helper rather than directly from the Haml source, which could result in the block being written when it shouldn’t:

```ruby
def a_helper &blk
  out = haml_capture &blk
  haml_concat(do_something_with(out) if some_condition
end
```
In general I think trying to change behaviour based on the name of a method like this is too fragile.