string/concatenation.rb tests are misleading

Ninguém assumiu esta issue ainda.

Hi, the tests in `string/concatenation.rb` are quite misleading.

The fast method consists of this

```
def fast
'foo' 'bar'
end
```

That's not concatenating during calling of `fast` but on parsing the code. If you write another method just returning `foobar`, it is as fast as this method.

So I think this is not fair comparison and what you usually want is to concatenate two variables during runtime.

For this use case `concat` and `<<` are calling the same code, so they have the same performance and both are fine if you want to change the string on the left and not just get two strings concatenated. If you want a new string you can use `+`.

Some better test could be to compare `+` and String interpolation

```
Benchmark.ips do |x|
foo = 'foo'
bar = 'bar'

x.report('String#+') do
foo + bar
end

x.report('String interpolation') do
"#{foo}#{bar}"
end

x.compare!
end
```

This still has the difference that interpolation can handle nil values, while `+` cannot.

Comece em string/concatenation.rb e inspecione como os benchmarks atuais definem o método rápido e comparam os métodos de concatenação. Use o exemplo de benchmark-ips da issue como referência, com variáveis de runtime para a comparação; o trabalho estará concluído quando o benchmark não tratar mais a concatenação feita em tempo de análise como uma operação de runtime e comparar de forma justa as alternativas indicadas.

Escrita pelo modelo de indexação a partir do texto da issue.