Refactor: Introduction of Formatting/Output Framework

This is a huge refactoring commit that does not change the functionality, yet.
Investigating the proper way to implement data formatting and output I saw that
the underlying framework in Powershell is very extensible.
So I introduced another framework that can and will be used for proper formatting
and output and should be easily extensible.

From a user's perspective there are two types of commands:
  * The Format-* family which formats the output but is independent of where
    the output goes to
  * The Out-* family which doesn't support formatting arguments but defines
    where the output goes to (console, file, null, ...)

The underlying mechanism works as follows:
The Format-* commands work the same in general an generate specific FormatData objects
that represent a document with the following structure
	FormatStart
		[GroupStart
			[FormatEntryData]*
		GroupEnd]*
	FormatEnd
where the []* denotes structures that can repeat (multiple groups). The FormatEntryData
includes the real data to be printed and might be a row of a table.

The content of these objects depend on the *Shape* of the output which might be
a table, a list, etc. Thus, it's generated by a specific FormatGenerator class for
the specified shape.

If a command of the Out-* family is called, it implicitly checks whether the input is
already formatted or invokes default formatting ("Format-Default").
The format data is than processed by a FormatProcessor, which of course depends again
on the shape of the output, as the FormatData objects may have different forms and contents.
For example the TableFormatGenerator generates some FormatEntryData that specifies the columns
used, etc. The TableFormatProcessor will the string representing the row of the table in the console
and passes the string to the OutputWriter.

The OutputWriter could then be a class that prints it to console, writes it to file or even creates
any other file including the formatted output.

For now, the FormatEntryData class, the TableFormatGenerator and TableFormatProcessor classes were
misused to implement the stupid old way of printing objects by simply using it's ToString() method.

The real implementations for at least the table and list view will with other commits.
Refactor: Distinction between formatting non-objects and objects
Table formatting, minor fixes

The main purpose is the implementation of table formatting, i.e. generating
FormatData and processing it.
Included are minor fixes and refactorings that were needed for the implementation
in order to work properly.

Also error processing has been reworked. Similar as simple data types, the output
of ErrorRecords/Exceptions differs from usual object output. Therefore
ErrorFormatEntryData was introduced which is, similar as SimpleFormatEntryData,
processed out of any document structure and has a default processing method.
List Formatting, minor fixes

Also list formatting (FormatData generation and processing) is now implemented.
Again, along with minor bug fixes and refactoring.

Depending on the data type, the proper format is chosen automatically:
	object has <= 5 properties: table
	otherwise list
which corresponds to PS behavior.

Note that we still deal with *all properties*. As soon as we support the
extended type system we need to properly implement the DefaultDisplaySet,
so we will only print selected properties of common objects.
Example: "foo".GetType() will now print all possible properties, not just
the important ones as PS does.
Adjustments of tests; Bugfixing

First of all, a TestHostRawUserInterface was added as its WindowSize property
is needed by the new output system.

More important:
Because of the new output system, it is important now to distinguish between
objects and their string representation. As the old output system always
just called ToString() several tests had to be adjusted to use either
a specific property for comparison or explicitly their string representation
(by using ToString() explicitly).
Moreover, Path related cmdlets had to be adjusted as they returned Path
objects, not strings as in PS, which lead to inconvinient results.
FormatManager as abstraction level to Format cmdlets.

The introduced FormatManager abstracts the actual formatting from the
FormatCommandBase cmdlet base class. This has the advantage that it can simply
be used in the OutCommandBase base class in order to format objects without
starting a separate pipeline. Also, the FormatManager can live along with the
Out-* cmdlet itself, so contiguous table output is possible.
TableFormat: Use same column alignments in one group
Tests for new Formatting

Some tests that check the new output mechanism with regard to the formatting.
Small adjustments in the test framework, s.t. the tests are possible.
Fixed bugs

Several bug fixes:
BufferSize has to be used for determining the output width instead of
the WindowWidth

The List format didn't include a newline between multiple objects.

Also the ListFormats used the same properties for each object, which
isn't necessary. Therefore the TableFormatProcessor itself cares about
which properties will printed and which  won't.

Added tests that check the detected bugs.
Fixed error occuring with redirected output