Formatting: Improve computation of available space

Before this change, context sent to #to_ruby usually contained only the
|width| property which contained the number of remaining characters
until the margin (hardcoded as 80 for now) *at the current line*. This
caused trouble e.g. in cases like this:

  1                        80
  |---------- ... ----------|

  LongModule.long_method([
    [
      item1,
      item2,
      item3
    ]
  ])

Although the nested array containing |item1|, |item2| and |item3| would
fit into one line, it was split into multiple lines because the passed
|width| was only 3 (the number of characters after the first |[| until
the margin.

This commit splits the original |width| property into |width| and
|shift|. The width has tha same semantics as it didi before, but it only
cares about the indent level, not about the code that is already on the
current line. The width of that code is stored in |shift|. As a result,
each #to_ruby method knows how much available space there is on the
*current line* and also on the *next lines*.
Formatting: Emit one-line blocks where possible
Ruby AST: Extract code-related utility methods into a module
Extract Y2R::AST::Ruby::Node#wrapped_line_list
Y2R::AST::Ruby::Node#wrapped_line_list: Tweak separators

Before this commit, a separator was emitted after the last item of an
array or a hash. After this commit, it isn't. This is in line with SUSE
Ruby coding conventions.
Formatting: Split expression lists to multiple lines when needed
Formatting: Split method calls to multiple lines when needed
Formatting: Emit blank lines around method definitions
Ruby AST: Add #single_line_width to nodes

The #single_line_width method returns width of Ruby code emitted for
given node if it fits a single line, or Float::INFINITY if it doesn't.
Now it is useless, but it will be used by improved formatting algorithm
(see the next commit).
Formatting: Improve the formatting algorithm performance

Before this commit, when a #to_ruby method needed to decide whether to
emit a single-line or multi-line version of Ruby code, it just tried to
generate the single-line version first and if it didn't fit to the
current line (as given by context), it used the multi-line one.

This algoritm worked, but it was exponential (in AST depth), which led
to horrible performance on real-world code, e.g. when there was a lot of
nested arrays. This was so bad that some YaST files didn't compile at
all on my machine (e.g. apparmor-settings.ycp).

This commit introduces a new algorithm. The #to_ruby method now decides
the single-line/multi-line question by calling #single_line_width on the
node (see the previous commit) and comparing it to remaining space on
the current line. This is still exponential in nature, but it's much
faster (we avoid actually generating code for all node's subnodes many
times), plus we can add caching of #single_line_width's result later if
needed. The apparmor-settings.ycp file seems to compile fine now.