I think that it is good enough for now to merge this

All tests are adjusted accordingly and swc_read_cells() is now removed.

Notable difference: parse_record() now throws only an swc_parse_error.
In case of an invalid_argument raised by the cell_record constructor,
this is caught and rethrown as a swc_parse_error with line information
attached.

Begin iterator resets the input stream.

Adde `-g' flag in compilation to allow debugging.

Use of cell record ranges for hiding the internals of file reading. This is
a proof-of-concept for a first peer review and discussion. Check usage
paradigm in corresponding test. Now we could easily support stateful parsing
reporting context of problematic lines.

Cell record cleaning + minor other improvements

Moved SWC parser's and cell record's implementation details to a
separate file. Also added braces around single-line control/loop blocks.

Read in cell records and do a basic cleaning:
  1. Remove duplicates.
     Only the first occurance is considered.
  2. Sort the records if not sorted.
  3. Ignore subsequent trees if more than one are specified.
  4. Renumber records if numbering is not contiguous.

This exception is thrown when a parse error occurs, instead of
std::runtime_error and std::logical_error that used to be thrown before.

The will be useful for sorting cell records. Equality and ordering is
defined solely on records IDs.

Refactor the project to have source and tests in different paths and use cmake.

Swc io

The line buffer is no more a pure character array but a standard string.
For reading lines from the input stream we use the higher level
std::getline() function which takes care of overflow issues.

Side improvements: String comment prefixes are now supported.

Other changes: added `-pedantic' to the compilation flags, to force
strict C++11 compliance.

The parser's semantics are now cleaner and the implementation more
robust. Cell parsing now follows the semantics of the standard input
stream (same as of standard UNIX's read), but instead of reading in
bytes or builtin types, we are reading full cell records. This has the
following implications:

1. Empty and comment lines are consumed silently.
2. End-of-file will be set on the stream only if a read operation
   returns zero. Practically, this means, eof bit will be set in the
   stream at the first attempt to read a cell record after the final
   cell record in the stream was read.
3. Exceptional conditions in the stream (e.g., eof or bad bits) stop the
   parsing process without raising an exception and return control to the
   user which is responsible to deal with them. The only exceptional
   condition that we handle internally is the presence of very long lines,
   in which case we raise an std::runtime_error().

Thanks to these cleaner semantics, the parser is now able to deal with
files not ending with a new line. The previous version would have missed
the last record.

Due to (2) the following code for reading from an input stream will
yield an additional default constructed cell record at the end:

while (!swc_input.eof()) {
    cell_record cell;
    swc_input >> cell;
    // do sth with the cell
}

According to (2), after the final record is read, eof is not yet set at
the stream, which means the while loop will be entered one more time.
The attempt to read a record from the stream then will raise the eof bit
and no cell will be read in, leaving `cell' at its default constructed
state. To avoid such a side-effect, the best way to read records from an
input stream is the following:

cell_record cell;
while( !(swc_input >> cell).eof()) {
    // do sth with the cell
}

In this case, after the final record is read, the next attempt to read
in a record will set the eof bit and won't enter the loop.