### Godot version

v4.1.dev3.official [a67d37f7c]

### System information

Linux 5.4.0-135-generic

### Issue description

I am trying to call Callable.rpc() and Callable.rpc_id(...) method but it doesn't work with some Callable.
If I call the .bind method and then call .rpc, I get the error "Invalid call. Nonexistent function 'rpc' in base 'Callable'.", execution aborts.

Issue is that we know for sure that the .rpc method in the Callable type is always present, and we would get a different error, but definitely not this one.

### Steps to reproduce

Create an empty project, a new scene with Node at the root, and attach the following script to it:
```GDScript
extends Node

@rpc
func foo(value = null):
	print("foo(%s)" % value)

func _ready():
	
	rpc("foo") # ok
	
	rpc("foo", 123) # ok
	
	foo.rpc() # ok
	
	foo.rpc(123) # ok
	
	foo.bind(123).rpc() # error: "invalid call. Nonexistent function 'rpc' in base 'Callable'."
	
	foo.bindv([123]).rpc() # error: "invalid call. Nonexistent function 'rpc' in base 'Callable'."
	
	foo.bind(123).unbind(1).rpc() # error: "invalid call. Nonexistent function 'rpc' in base 'Callable'."
	
	foo.bindv([123]).unbind(1).rpc() # error: "invalid call. Nonexistent function 'rpc' in base 'Callable'."
	
```
Run the scene and observe the error. After an error, execution is interrupted, so comment out the found line to find the next error. Run the scene again.

See all available function values for these Callables. Except Callable.get_method() but that's a whole other issue.
```GDScript
	for callable in [foo, foo.bind(123), foo.bindv([123]), foo.bind(123).unbind(1), foo.bindv([123]).unbind(1)]:
		print("%6s ".repeat(11) % [
			callable,
			callable.get_bound_arguments(), callable.get_bound_arguments_count(), "callable.get_method()", callable.get_object(), callable.get_object_id(),
			callable.hash(), callable.is_custom(), callable.is_null(), callable.is_standard(), callable.is_valid()
		])
```

### Minimal reproduction project

N / A
r_arguments = Vector<Variant>();
		return;
	}
	r_arguments.resize(new_count);
	if (sub_count > 0) {
		for (int i = 0; i < sub_count; i++) {
			r_arguments.write[i] = sub_args[i];
		}
		for (int i = 0; i < binds.size(); i++) {
			r_arguments.write[i + sub_count] = binds[i];
		}
		r_argcount = new_count;
	} else {
		for (int i = 0; i < binds.size() + sub_count; i++) {
			r_arguments.write[i] = binds[i - sub_count];
		}
	}
}
void CallableCustomBind::call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, Callable::CallError &r_call_error) const {
	const Variant **args = (const Variant **)alloca(sizeof(const Variant **) * (binds.size() + p_argcount));
	for (int i = 0; i < p_argcount; i++) {
		args[i] = (const Variant *)p_arguments[i];
	}
	for (int i = 0; i < binds.size(); i++) {
		args[i + p_argcount] = (const Variant *)&binds[i];
	}
	callable.callp(args, p_argcount + binds.size(), r_return_value, r_call_error);
}
CallableCustomBind::CallableCustomBind(const Callable &p_callable, const Vector<Variant> &p_binds) {