Zir: eliminate `field_call_bind` and `field_call_bind_named`

This commit removes the `field_call_bind` and `field_call_bind_named` ZIR
instructions, replacing them with a `field_call` instruction which does the bind
and call in one.

`field_call_bind` is an unfortunate instruction. It's tied into one very
specific usage pattern - its result can only be used as a callee. This means
that it creates a value of a "pseudo-type" of sorts, `bound_fn` - this type used
to exist in Zig, but now we just hide it from the user and have AstGen ensure
it's only used in one way. This is quite silly - `Type` and `Value` should, as
much as possible, reflect real Zig types and values.

It makes sense to instead encode the `a.b()` syntax as its own ZIR instruction,
so that's what we do here. This commit introduces a new instruction,
`field_call`. It's like `call`, but rather than a callee ref, it contains a ref
to the object pointer (`&a` in `a.b()`) and the string field name (`b`). This
eliminates `bound_fn` from the language, and slightly decreases the size of
generated ZIR - stats below.

This commit does remove a few usages which used to be allowed:
- `@field(a, "b")()`
- `@call(.auto, a.b, .{})`
- `@call(.auto, @field(a, "b"), .{})`

These forms used to work just like `a.b()`, but are no longer allowed. I believe
this is the correct choice for a few reasons:
- `a.b()` is a purely *syntactic* form; for instance, `(a.b)()` is not valid.
  This means it is *not* inconsistent to not allow it in these cases; the
  special case here isn't "a field access as a callee", but rather this exact
  syntactic form.
- The second argument to `@call` looks much more visually distinct from the
  callee in standard call syntax. To me, this makes it seem strange for that
  argument to not work like a normal expression in this context.
- A more practical argument: it's confusing! `@field` and `@call` are used in
  very different contexts to standard function calls: the former normally hints
  at some comptime machinery, and the latter that you want more precise control
  over parts of a function call. In these contexts, you don't want implicit
  arguments adding extra confusion: you want to be very explicit about what
  you're doing.

Lastly, some stats. I mentioned before that this change slightly reduces the
size of ZIR - this is due to two instructions (`field_call_bind` then `call`)
being replaced with one (`field_call`). Here are some numbers:

+--------------+----------+----------+--------+
| File         | Before   | After    | Change |
+--------------+----------+----------+--------+
| Sema.zig     | 4.72M    | 4.53M    | -4%    |
| AstGen.zig   | 1.52M    | 1.48M    | -3%    |
| hash_map.zig | 283.9K   | 276.2K   | -3%    |
| math.zig     | 312.6K   | 305.3K   | -2%    |
+--------------+----------+----------+--------+

1 files changed, 0 insertions, 20 deletions

diff --git a/src/value.zig b/src/value.zig
index 503797abba..93edf60eb2 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -183,10 +183,6 @@ pub const Value = extern union {
         /// Used to coordinate alloc_inferred, store_to_inferred_ptr, and resolve_inferred_alloc
         /// instructions for comptime code.
         inferred_alloc_comptime,
-        /// Used sometimes as the result of field_call_bind.  This value is always temporary,
-        /// and refers directly to the air.  It will never be referenced by the air itself.
-        /// TODO: This is probably a bad encoding, maybe put temp data in the sema instead.
-        bound_fn,
         /// The ABI alignment of the payload type.
         lazy_align,
         /// The ABI size of the payload type.
@@ -326,7 +322,6 @@ pub const Value = extern union {
                 .inferred_alloc_comptime => Payload.InferredAllocComptime,
                 .aggregate => Payload.Aggregate,
                 .@"union" => Payload.Union,
-                .bound_fn => Payload.BoundFn,
                 .comptime_field_ptr => Payload.ComptimeFieldPtr,
             };
         }
@@ -477,7 +472,6 @@ pub const Value = extern union {
             .extern_options_type,
             .type_info_type,
             .generic_poison,
-            .bound_fn,
             => unreachable,
 
             .ty, .lazy_align, .lazy_size => {
@@ -837,10 +831,6 @@ pub const Value = extern union {
                 try out_stream.writeAll("(opt_payload_ptr)");
                 val = val.castTag(.opt_payload_ptr).?.data.container_ptr;
             },
-            .bound_fn => {
-                const bound_func = val.castTag(.bound_fn).?.data;
-                return out_stream.print("(bound_fn %{}(%{})", .{ bound_func.func_inst, bound_func.arg0_inst });
-            },
         };
     }
 
@@ -5657,16 +5647,6 @@ pub const Value = extern union {
                 val: Value,
             },
         };
-
-        pub const BoundFn = struct {
-            pub const base_tag = Tag.bound_fn;
-
-            base: Payload = Payload{ .tag = base_tag },
-            data: struct {
-                func_inst: Air.Inst.Ref,
-                arg0_inst: Air.Inst.Ref,
-            },
-        };
     };
 
     /// Big enough to fit any non-BigInt value