Refactor 'struct context *ctx = &actx' pattern.

When I'm declaring a local instance of some context structure type to
pass to a function which will pass it in turn to a callback, I've
tended to use a declaration of the form

    struct context actx, *ctx = &actx;

so that the outermost caller can initialise the context, and/or read
out fields of it afterwards, by the same syntax 'ctx->foo' that the
callback function will be using. So you get visual consistency between
the two functions that share this context.

It only just occurred to me that there's a much neater way to declare
a context struct of this kind, which still makes 'ctx' behave like a
pointer in the owning function, and doesn't need all that weird
verbiage or a spare variable name:

    struct context ctx[1];

That's much nicer! I've switched to doing that in all existing cases I
could find, and also in a couple of cases where I hadn't previously
bothered to do the previous more cumbersome idiom.

unix/gtkask.c

@@ -569,7 +569,7 @@ const bool buildinfo_gtk_relevant = true;
 char *gtk_askpass_main(const char *display, const char *wintitle,
                        const char *prompt, bool *success)
 {
-    struct askpass_ctx actx, *ctx = &actx;
+    struct askpass_ctx ctx[1];
     const char *err;
 
     ctx->passphrase = NULL;