Support REQUEST_GETNEXT by allowing callback to return a different OID.

Previously, the API only supported returning the requested OID, which made
it impossible for the callback to return the "next" OID (the one actually
used in REQUEST_GETNEXT requests).
Added a new string syntax

They will all start and end a literal string.

A literal string can contain any characters except the end sequence.

The main usecase is writing code in a string.

As an example:

string test = #{
This is a literal string.
They can contain any characters, no de-quoting is done at all.

So, as an example, foo "bar" 'gazonk' \

Valid quote sequences are #{, #( and #[.
They are ended by # followed by }, ) and ], respectively.

So, you can use the two other quotes inside the string, if you want to, like:

Also, no preprocessing is done inside the string.

The main usecase for these strings is to write code in code.
Added change entry for the new syntax.

Sorry for the messed up commit message previously, it happened since
the character # starts a comment in commit messages.
Merged the const-marked pike_interpreter_pointer branch.

We now lie to the compiler about the const:ness of the
Pike_interpreter_pointer variable.

Most code now pretends that that variable is constant (it's not,
really, it's constant /per thread/, but not globally, however, the
only code that writes to it and expects anything but the same value
each time it is read is in thread.c)

This saves a lot of code when using the stack multiple times in a
function, and should be safe enough, albeit somewhat unconventional.

If nothing else the binary size shrunk by about 5%.

This _will_ cause issues if pike is compiled with link-time
optimization. A better solution would be an actual thread local
pointer, which is const marked. Or, perhaps the best solution, having
the whole pike_interpreter_struct structure be thread local. At least
on x86_64 accessing thread-local data is just about as fast as
accessing global data.
[Fuse] remove redundant code around call_with_interpreter()

Fixes compilation, and removes unneccessary code.
Added notes about some more changes
Moved random() note
Nettle.BufferedCipher: Support larger padding in unpad().

Support padding larger than the cipher block size.

Support padding larger than 127 bytes on architectures with signed char.

The above are needed to interoperate with GnuTLS (which often uses quite
long padding).

Also attempts to make the padding checking code more time-invariant.