instead of single I/O request per step, the daemon now retries
all addresses in the selection with 300ms timeout between tries.
there are len(list) + len(list)/2 tries

the idea is to reduce latency when UDP request doesn't punch through,
or some NSs are overwhelmed/faulty

if the library or daemon is compiled with address sanitizer, objects in
freelists are poisoned to detect use-after-recycle errors
it is not currently used in the library, as there are no freelists

this is going to be needed for issuing multiple timed queries + fast
retry

the selected address is now an array with selection, caller can then send the same query to multiple offered targets

refs #35

example:

worker.resolve('cz', kres.type.NS, kres.class.IN, 0,
function (pkt)
	local answer = kres.pkt_t(pkt)
	print (answer:rcode())
end)

the reason is that it's not actively used since we moved to binary
testing, and it depends on libknot internal api that has changed
also removed several unused libknot internal headers

the requestor can provide information identifying the query originator
here (address and TSIG key), both fields are optional
update Lua FFI bindings

the memory could go through the roof with sufficiently high pps, GC now runs at 4x the speed of allocations and doesn’t wait for increase, some callbacks also perform full collection cycle on completion

this fixes a problem when a module was removed, but pending
queries referenced it, causing a crash. usually when the
server was busy and a module was unloaded.
as we don’t need to copy layers at all, they’re just iterated
from the array of modules using a macro

before only current I/O handle was tracked for each subrequest, but the
requests may have outlived it (connect request isn't cancelable for
example), if such request terminated after the request was finished,
it checked the address of potentially stale task

when the timeout event was fired, it started another step in query
resolution, but there may have been pending events on previous handle
if the events on the previous handle completed, they would check the
memory of their task (which may have been non-existent) and possibly
double-close the handle

an average request from cache requires ~12k, an average iterative request 16-64k
this reduces allocation cost when there are now pools on the freelist

since the structures are ~ same size as I/O requests (udp_send_t being 60B larger than others), they all share the same freelist

this can coalesce sends/writes in future versions of libuv

This reverts commit 91a2945e.

Conflicts:
	daemon/worker.h

this avoids repetitive allocation/free cycles on load