Composition over inheritance

Please have a look at #14 for the rationale behind this choice.

Closes #14 

## [Benchmarks](https://gist.github.com/jodosha/87c4bbdb9bb80fea2874):
### String
#### TL;DR got a little bit worst.

#### Before (inheritance)

```
                                     user     system      total        real
#initialize                      0.470000   0.000000   0.470000 (  0.471006)
#classify                        2.030000   0.070000   2.100000 (  2.107922)
#underscore                      5.450000   0.240000   5.690000 (  5.706362)
#demodulize                      0.570000   0.000000   0.570000 (  0.577132)
#namespace                       0.610000   0.000000   0.610000 (  0.606817)
#tokenize                       11.100000   0.560000  11.660000 ( 11.696167)
```

#### After (composition)

```
                                     user     system      total        real
#initialize                      0.360000   0.010000   0.370000 (  0.371044)
#classify                        2.590000   0.050000   2.640000 (  2.648675)
#underscore                      6.670000   0.220000   6.890000 (  6.913424)
#demodulize                      1.040000   0.000000   1.040000 (  1.047517)
#namespace                       0.970000   0.000000   0.970000 (  0.970059)
#tokenize                       12.450000   0.530000  12.980000 ( 13.030900)
```

### Hash
#### TL;DR got a little bit worst, but gained a lot for nested symbolize.

#### Before (inheritance)

```
                                     user     system      total        real
#initialize                      1.550000   0.180000   1.730000 (  1.753729)
#initialize default              0.800000   0.110000   0.910000 (  0.940170)
#symbolize!                      1.930000   0.030000   1.960000 (  1.970735)
#symbolize! nested               5.880000   0.400000   6.280000 (  6.355637)
```

#### After (composition)

```
                                     user     system      total        real
#initialize                      1.020000   0.100000   1.120000 (  1.119302)
#initialize default              1.340000   0.090000   1.430000 (  1.481947)
#symbolize!                      2.530000   0.030000   2.560000 (  2.577319)
#symbolize! nested               0.760000   0.000000   0.760000 (  0.770620)
```

### PathPrefix
#### TL;DR no relevant changes

#### Before (inheritance)

```
                                                                                                           user     system      total        real
#join between a blank string and a string without the leading slash                                   16.040000   1.350000  17.390000 ( 17.394150)
#join between two strings without leading slash                                                       16.310000   1.190000  17.500000 ( 17.517221)
#join between a string with the leading slash and one without the leading slash                       19.840000   1.190000  21.030000 ( 21.042403)
#join between a blank string and a string with the leading slash                                      17.440000   0.900000  18.340000 ( 18.356298)
#join between one string without the leading slash and one with                                       18.610000   0.560000  19.170000 ( 19.189977)
#join between two strings with the leading slash                                                      21.360000   0.490000  21.850000 ( 21.858214)
#relative_join between a blank string and a string without the leading slash                          13.340000   0.400000  13.740000 ( 13.747319)
#relative_join between two strings without leading slash                                              14.360000   0.360000  14.720000 ( 14.731586)
#relative_join between a string with the leading slash and one without the leading slash              17.310000   0.440000  17.750000 ( 17.757787)
#relative_join between a blank string and a string with the leading slash                             15.200000   0.430000  15.630000 ( 15.647355)
#relative_join between one string without the leading slash and one with                              17.560000   0.430000  17.990000 ( 18.012233)
#relative_join between two strings with the leading slash                                             19.700000   0.500000  20.200000 ( 20.203182)
```

#### After (composition)

```
                                                                                                           user     system      total        real
#join between a blank string and a string without the leading slash                                   15.810000   1.310000  17.120000 ( 17.125978)
#join between two strings without leading slash                                                       16.200000   1.200000  17.400000 ( 17.413818)
#join between a string with the leading slash and one without the leading slash                       19.620000   1.170000  20.790000 ( 20.791665)
#join between a blank string and a string with the leading slash                                      17.240000   0.830000  18.070000 ( 18.072123)
#join between one string without the leading slash and one with                                       18.480000   0.510000  18.990000 ( 19.005753)
#join between two strings with the leading slash                                                      21.150000   0.490000  21.640000 ( 21.645602)
#relative_join between a blank string and a string without the leading slash                          13.570000   0.440000  14.010000 ( 14.017557)
#relative_join between two strings without leading slash                                              15.150000   0.360000  15.510000 ( 15.520849)
#relative_join between a string with the leading slash and one without the leading slash              17.590000   0.430000  18.020000 ( 18.033260)
#relative_join between a blank string and a string with the leading slash                             15.680000   0.460000  16.140000 ( 16.140308)
#relative_join between one string without the leading slash and one with                              17.340000   0.420000  17.760000 ( 17.775007)
#relative_join between two strings with the leading slash                                             19.510000   0.470000  19.980000 ( 19.984774)
```
@jc00ke TL;DR because it's the safest way.

End developers may include gems who monkey-patch `String` and eventually override `#send`.
It's crazy, but I've seen this, and I always wondered if it the library author didn't knew about this Ruby special method and accidentally overridden it, or they wanted to enrich Ruby's default behavior.

Those are the reasons why `#__send__` was introduced in the language.
Now, if you override it, the VM prints a warning.

```ruby
irb(main):001:0> class WarningTest
irb(main):002:1> def __send__(*args)
irb(main):003:2> end
irb(main):004:1> end
(irb):2: warning: redefining `__send__' may cause serious problems
=> :__send__
```

I really hope that it will never touched by anyone, that's why I used it.