Make string concat, copy and move work on non-terminated strings

Previously, these methods took a
nul-terminated string and appended it to the current buffer. The length
argument (or length of the passed String object) was used to allocate
memory, but was not used when actually copying the string. This meant
that:

 - If the length was not correct, or the string passed in was not
   nul-terminated, the buffer would overflow.
 - If the string passed in contained embedded nul characters (e.g, in
   among the first length characters), any characters after the embedded
   nul would not be copied (but len would be updated to indicate they
   were).

In practice, neither of the above would occur, since the length passed is
always the known length of the string, usually as returned by strlen.
However, to allow using this concat method to pass in strings that are
not nul-terminated, its behaviour should change.

This commit changes the method to use memcpy instead of strcpy, copying
exactly the number of bytes passed in. For the current calls to this
method, which pass a nul-terminated string, without embedded nul
characters and a correct length, this behaviour should not change.

However, this concat method can now also be used in the two cases
mentioned above. Non-nul-terminated strings now work as expected and for
strings with embedded newlines the entire string is copied as-is,
instead of leaving uninitialized memory after the embedded nul byte.

Note that a lot of operations will still only see the string up to the
embedded nul byte, but that's not really fixable unless we reimplement
functions like strcmp.
Use memmove in String::remove

Before, it used strncpy, but that has undefined behaviour when the
source and destination strings overlap. memove is guaranteed to work
correctly in this case.

Note that memmove simply copies all bytes, whereas strncpy stopped at
the first nul-byte. This measn this commit also makes remove work for
strings that contain embedded nul bytes.
Simplify String::concat(char)

Now concat(const char*, unsigned int) no longer requires a
nul-terminated string, we can simplify the concat(char) method to just
pass the address of the single character instead of having to create
buffer with nul-termination.
Make String::concat(const char *, unsigned int) public

This method is useful when receiving data from external sources that
pass an explicit length instead of a NUL-terminated string.
Add String(char *, unsigned) constructor

This constructor allows converting a buffer containing a
non-nul-terminated string to a String object, by explicitely passing the
length.
Remove unneeded check from String::setCharAt

operator[] already checks the index and returns a dummy writable
reference when the index is out of bounds.
Remove unneeded check in String::remove(unsigned int)

This check already happens in the remove(unsigned int, unsigned int)
method that is caled, so there is no need to also check this here.
Fix bounds check in String::remove()

Previously, if you passed in a very big index and/or count, the
`index + count` could overflow, making the count be used as-is instead
of being truncated.

We can rewrite the comparison to use `len - index` instead. Since we
know that index < len, we are sure this subtraction does not overflow,
regardless of what values of index and count we pass in.

As an added bonus, the `len - index` value already needed be calculated
inside the if, so this saves a few instructions in the generated code.
Simplify String::remove(unsigned int)

Previously, this method calculated the length of the string from the
given index onwards. However, the other remove() method called already
contains code for this calculation, which is used when the count passed
in is too big. This means we can just pass in a very big count that is
guaranteed to point past the end of the string, shrinking the remove
method by a few bytes.
Don't mess with the original in String::substring

Before, substring would (temporarily) add a \0 in the original string at
the end of the substring, so the substring could be copied into a new
String object. However, now that the String::copy() method can work with
non-nul-terminated strings (by passing an explicit length), this trick
is not needed and we can just call the copy method instead.
Allow negative indices in String::operator[] and String::remove()

Thes negative indices indicate the number of characters from the end of
the string.