[DRAFT] [pulse] do not keep the arguments of pure calls alive through their result

[VladimirMakaev]

Pulse records calls to unknown functions that cannot write through their arguments as v = f(x).
Summaries kept x alive through this equality whenever v was live, which hid leaks of x and
made summaries grow exponentially along trees of such calls.

#include <stdlib.h>

int read_through_const_pointer(const int* p); // unknown

int leak_bad() {
  int* p = malloc(sizeof(int));
  if (p == NULL) {
    return 0;
  }
  return read_through_const_pointer(p); // Infer missed: memory leak
}

Now the result and the other arguments no longer keep a dead argument alive, unless callers can
compute it again, like g() in f(g()); the equalities that mention it are dropped.

This exposed a bug: inlining the initializer of a global constant argument, as in
exchange(fd_, kInvalid), could overwrite another argument of the call. It no longer does.

Limitations: this applies to all allocations (malloc, new, file descriptors, CoreFoundation
objects, C# resources):

• unknown functions that close a descriptor or return their pointer argument now cause leak reports,
  e.g. return my_close(fd);. On libuv 1.48, this adds 2 PULSE_RESOURCE_LEAK false positives, at
  src/unix/pipe.c:130 (uv_pipe_bind2) and src/unix/tcp.c:78 (new_socket), where a helper
  closes the descriptor or keeps it; main already reports 2 of this kind in new_socket.
• results of calls sharing a dead argument are no longer related.

Test plan

New leak tests in c/pulse/memory_leak.c, c/pulse/resource_leak.c and cpp/pulse/leaks.cpp,
with FP_ tests for the limitations, and ground pure call and global constant tests. A depth-16
tree of combine(f(), f()) calls over a local buffer took 6.7 s and a 14 MB results database
before, 0.1 s and 0.2 MB after. Codetoanalyze tests pass.