Convert most buffers to use StringBuffer

This uses the StringBuffer object for most buffers in ScoutHandler.cpp
and Shell.cpp. The StringBuffer objects encapsulate all memory
management, automatically freeing up their memory when they go out of
scope.

When returning a StringBuffer object, the compiler automatically causes
the StringBuffer object itself to be allocated by the caller (return
value optimization) and the buffer is not copied (copy-elision) but just
passed to the caller and automatically freed in the caller.

When passing a buffer or string argument, some cases are modified to use
a const String&, but sometimes a const char* is still used, because
there isn't always a String object available in the caller (and creating
one currently always involved copying the entire string). This part
should be cleaned up a bit, but it's less important (since converting a
String or StringBuffer to char* is easy with the c_str() method).

This fixes #79.

Additionally, this commit moves the JSON escaping for commands ran by
field scouts from bitlash output function on the field scout to the
HQ-related functions on the lead scout, which make a lot more sense.

In addition to converting buffers, this also cleans up the buffer
handling in some places, which also fixes #86.
Add free() for remaining memory leaks
Let leadSignal accept a const String&

Every caller had a StringBuffer object that was converted to a char*, so
might a well pass the actual object.

Inside leadSignal, the String is now passed to the wifi client print
method instead of write. This means that the length stored in the
String object is used, saving a strlen call.
Add ConstString and ConstBuf classes

These classes make it easier to pass char* around, without forcing the
complete string copy that would be needed to turn them in to regular
String objects.
Add StringBuffer::concat version for uint8_t*
Pass a ConstBuf& instead of char* where possible

Previously, char* were passed, even when they were not guaranteed to be
nul-terminated (in particular, packets received over the mesh were not
guaranteed to be nul-terminated). Now, a ConstBuf object is passed,
which includes the length, preventing out-of-bounds reads.

This removes most of the c_str() calls from ScoutHandler. The ones
remaining are for interfacing with external things, like bitlash, js0n
and sprintf, which we cannot change to accept anything else.
Remove debug print from StringBuffer
Allow passing a ConstBuf to StringBuffer::appendJsonString

Indirectly, this also allows passing a char*, String& and StringBuffer&,
so the original char* version can be removed.
Fix if inside appendJsonString

There was a stray semicolon, that caused appendJsonString to only
reserve space and never actually copy bytes.
Fix escaping in appendJsonString

Previously, appendJsonString kept a char *out, pointing to the next
character to write that was valid throughout the entire function.
However, when characters needed to be escaped, usually the reserved
buffer would be too small and a second reallocation was needed. This
could change the address of the buffer, making the out pointer invalid.

To fix this, reset the out pointer at the start of each try and keep an
explicit count of bytes written so we know where to point it.
Don't send debug output to bitlash in ScoutHandler::announce

If that function is called from inside a bitlash command coming from HQ
(e.g. when a led report is triggered when running "led.red"), the debug
output would end up inside the command reply.
Apply JSON escaping to HQ command output on lead scouts

Previously, the output from field scouts was escaped, but output from
the lead scout itself was just passed on unescaped.
Free the received command after executing on a field scout

Previously, it would execute the first command received over and over
again.
Remove bitlashBuffer function

It was no longer used, replaced with printToString. Also remove the
declaration for preapreBitlashBuffer, whose implementation was removed a
few commits ago.
Remove bitlashFilter function

This function was used to redirect bitlash output to in the normal case
(e.g. when not running HQ commands). However, this function simply
prints to Serial, so it makes more sense to just reset the output
handler and let bitlash print to Serial itself.

This function was probably a remnant from when things were structured
differently.