This reverts commit 2baff3dc.

This reverts commit 05780b63.

If we have to choose between this warning and alpine being part of our
CI, this warning takes precedence. It's always possible to disable
developer warnings on CCI if that's a problem with musl then we can
configure its CCI job to disable developer warnings.

Reopens #3565
Refs #3568

The +table flag causes all overlapped ACL entries to be compiled
as usual, and non-overlapped entries to be emitted as a table of
bytes.

When testing the ACL the compiled code is run before VPI_acl_table()
is used to do a binary search on the table.

Even with a binary search, the table is approx 3 times slower than
the regular compiled ACLs (ie: only "blindingly fast" as oppposed
to "lighting fast").

The advantage of +table is that C-compilers literally take no time,
no matter the size of the ACL, where they will take seconds
or even minutes compiling large ACLs as code.

Fixes #3571

Closes: #3570

We used the -t argument only for the VSM attach, not for the actual CLI
operations.

I do not think the complication of differentiated timeouts is justified,
so just use the one timeout parameter we have for both. Also I think
that the documentation is already adequate in its simplicity:

       -t timeout
              Wait no longer than this many seconds for an operation to
              finish.

Fixes #3542

We use another "method" bitmask to record the built-in subs from which
static calls originate.

This allows us to indentify those subs which are called from
housekeeping only, allowing us to selectively disable compiler
optimizations.

VGC diff for the example from
https://github.com/varnishcache/varnish-cache/issues/3545#issue-824634168

```diff
@@ -2242,7 +2278,7 @@

 #define END_ if (*ctx->handling) return

-void v_matchproto_(vcl_func_f)
+void v_dont_optimize v_matchproto_(vcl_func_f)
 VGC_function_a(VRT_CTX, enum vcl_func_call_e call,
     enum vcl_func_fail_e *failp)
 {
```

Fixes #3545

Reported by Justin Lloyd.

Refs #3565

See Also: #3557

Also compare in the exact resp.body, because now we can.

This is a TTFB optimization: I noticed that, when streaming, we would
only sometimes send headers while waiting for more body data from the
backend, depending on the amount of body data read ahead when reading
the backend headers.

The flush_head debug bit would avoid the delay, but it leads to an extra
flush in all cases, even when we could send some body data down the line
with the headers.

This trivial patch peeks into the busy object to determine if the
first ObjWaitExtend() is likely to block and, if so, issues a flush,
which will cause the headers to be sent in addition to any initial data
VDPs might have to send.

The assertion that the stale objcore of a conditional fetch cannot be
failed unless it was streaming is incorrect. Between the moment when
we grab the stale objcore in HSH_Lookup and the moment we try to use
it after vcl_backend_response, the backend fetch may have completed or
failed.

Instead, we need to treat an ongoing fetch and a failed fetch as
separate checks since the latter may happen with or without a boc.