[RFC] Ensure well-defined alloc behaviour.

clang defect report [1] caught this potential bug in memory.c, line 112:

> Call to 'calloc' has an allocation size of 0 bytes

calloc(0,x) or (x,0) and malloc(0) may return a NULL or non-NULL pointer
[2] on some implementations. Set the size and/or count to at least one
before calling an alloc() function to avoid undefined behaviour.

[1] defect report:
http://ruiabreu.org/neovim-analysis/report-oLRUxF.html#Path4

[2] http://man.he.net/man3/calloc

I'm certain that no code using `xcalloc()` right now is broken. I experimentally found that gcc will zero-fill at least 24 bytes of space, even on `calloc(0,0)`, but I hope nothing actually relies on that behaviour.

```c
#include <stdlib.h>
#include <stdio.h>

int main() {
    char* p = calloc(0,0); // OOPS!

    if( p == NULL ) return 1;

    size_t i = 0;
    for( ; p[i] == 0; i++ )
        printf("char @ %zu = %i\n", (size_t)p + i, (int)p[i]);
    printf("char @ %zu = %i\n", (size_t)p, (int)p[i]);

    free(p);
    return 0;
}
```
Tested with:
```bash
$ gcc alloc.c
$ ./a.out | wc --lines
25
```

static analyser: #167 
> If some client code calls xmalloc with size 0 it shouldn't read the
allocated memory. It is bug and there's nothing reliable you can do inside
x*alloc to solve that. [snip] 

That makes sense, and thinking about it a little more, I see why the current implementation is OK. `malloc(0)` can return `NULL` or a pointer to a free-able object. If the implementation returns `NULL`, it calls `malloc(1)`, but only when `size==0` since it really doesn't matter at that point how much space the client gets--it shouldn't be accessed. If the implementation returns a free-able pointer, that's OK for the same reason.

>  I only resort to that if the system allocation function can't handle that by itself.

If `size==0` and the first `malloc()` returned `NULL`, then indeed it seems very likely that the implementation does not allocate space for `malloc(0)`.

The assumptions `xmalloc` and `xcalloc` make about implementation-defined behaviour and how to do what the client expects do not seem obvious. Some documentation might help.