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 :)
Well, to be truly honest I'm not 100% satisfied with this solution either, but I don't see another one. The most common case of using `haml_capture` in an helper, is because it needs the content and will probably output something, then  this case is already solved by `compile_script`. The `silent_script` however is more sneaky, but if we could say "if you want to use the content of a block, you should always use `=`", then the problem will be solved. If they still don't want to output anything (block content included), they can simply return an empty string as the result.
```haml
= models.each do |m|
   = model.name
```
I think this syntax is totally acceptable. This will not change in the actual version of HAML, that's obvious, but maybe on the next major version this could be introduced, what do you think? For know, we can just stick with this.

Oh, while writing I've had a new idea: what if we convert a `silent_script` to `script` if one of the children is a `script`? I will do some test when possible (probably on the weekend), but I want to know your opinion :)