Don't initialize queues with init value

This is the start of a considerable overall of the system.

Signals, or rather, queues have initialization values to solve the
problem of feedback loops. When a block tried to read a queue that
depended on its own output, it deadlocked. Example:

 ______________________
|      ___________     |
 -->  |           |    |
      |   BLOCK   |----
--->  |___________|

Initializiation solved this problem because that feedback signal
would have an initial bogus value. However, it also introduces a
major problem - the delay in signals is non-deterministic. Oon
complex diagrams, it's impossible to tell if the sample the block
reads is from the current cycle or from N cycles ago.

After much consideration, me and my collegues have reached the
conclusion that the best approach to solve the feedback problem
is not init values but delays blocks. Example:
       ___________
      |           |
 ---- |   Z^-1    |<---
|     |___________|    |
|      ___________     |
 -->  |           |    |
      |   BLOCK   |----
--->  |___________|

The major drawback is that the user can now design a diagram that
will not run. This is a major usability issue. This needs to be
very tightly controlled, both from the block library and XL itself.
With propper error support, we might be able to warn the user that
signal X has timedout and this is a sign of cyclical dependency.

Further study will have to be done on this. As an example to
illustrate the complexity, right now we can kill  'tick' and that
event alone will propagate down the diagram and make blocks exit
cleanly. There's a tight balance act between when a signal times
out and when its queue descriptor becomes invalid. Also consider
what happens when a block seg faults crashes. Every block down the
line will time out, even though it's not a cyclical dependecy
issue.

Like I said, further study is needed on this.
Assume [0] and retire askForLineValue()

We need all traces of matrix initialization, all the way up to the
.xlb file spec, but for now, let's just spare the user of having to
enter a useless value.
Erase all traces of init values

This was done with very little testing, so the only thing assuring
that all traces have indeed been erased and the code is still
working is hope.
Add config_file to debugframe

This is essential to distinguish between various blocks of the same
type.
Improve debug's dump to console
Clean-up some old code and comment a debug line

This might come in handy some time in the near future, so I'm
keeping it in.
Silence killall's stderr

This was appearing as a non-formated error message.
Change goodbye message so it indicates success
Convert line endings to unix
Decouple mtx library from rt_block_io macros

No more RETERROR/ERROR/DEBUG. This stills needs more work, as
there's no reason for this library to ever call MTXERROR(), which
was added as a quick fix for a major structural problem.
Force removal of Makefiles in settings_gui

If the build is interrupted for some reason, these Makefiles may be
left in a corrupt state. Yet, they won't update because there's no
reason to do so, dependency wise.

So, as a recap. When we run a `cleanall`, we remove the Makefiles,
generate them with QMake, run `clean` on them, and then remove them.
Define DEBUG/ERROR macros in commonmacros.h
Improve handling of timeout in read_inputs()

Since queues don't have an initilization value anymore, it's now
possible that a user draws a diagram that just won't run. This
really ups the stakes in terms of error handling. This commit does a
general cleanup of the function, and uses a tick counter to test if
the timeout happened before the first sample or after it.

If it's before the first sample, this timeout was most likely caused
by cyclical dependency. It might also be that the parent block just
segfaulted before writing to the queue, but that's quite rare.

If it's after the first sample, it's clearly not from a cyclical
dependency.

Over the next commits a testsuite will be rolled in that will
explain and expose this behavior more specificaly.
Fix typo
Implement Z^-N block (delay)

This took a lot of work, especially on the testing side (which still
hasn't made it to the repository). Anyway, this commit adds the Z^-N
block and makes the necessary changes to rt_block_io.* to support
it.

The Z^-N block is, in itself, trivial. The only thing it does is
write an inital value N times to its output queues. To allow for
this simples implementation, the way queues are configured had to
change. Queues are now configured as FIFO, don't have initial
values, and allow are large enough for a decent number of samples to
be queued up.

Some notes on the implementation. First we rename MAX_MESSAGE_LENGTH
to MAX_QUEUE_LENGTH, which makes much more sense.

Each queue used to have a pool of memory of sizeof(Matrix) bytes,
and a maximum number of samples queued up MAX_QUEUE_LENGTH=1. They
are now configured as the debug queue, with a pool
MAX_QUEUE_LENGTH*sizeof(Matrix) and MAX_QUEUE_LENGTH possible
samples to queue up.

MAX_QUEUE_LENGTH has been set to 11, so we can set N up to 10. This
way Z can queue 10 initial values and the first result of whatever
comes before it.

The queue was set to FIFO operaton by changing the call to
rt_queue_write. Before it was Q_URGENT, which made the sample be
written on the top of the stack, but now it's Q_NORMAL, which
assures the FIFO behavior.
Don't print message if debug queue is full

This is unnecessarily polluting stdout when the debug block isn't
running.
Change signal_generator default to a square wave
Add first draft of integration tests

This is the first version of integration tests. The README within
contains a more detailed explanation of how they work.