Ignoring extra arguments is a lot simpler to implement, and can actually be useful.
In a typical implementation e.g. libstdc++ (g++), the approach taken is to collect the operator() arguments into a tuple and then let the std::placeholder bind arguments extract them as required. Enforcing argument count would require counting the number of used placeholders, which would be pretty complicated. Note that the bind callable can be a functor with multiple or templated operator() call patterns, so the bind object operator() can’t be generated with a single “correct” signature.
Also note that you can write:
std::bind(&foo, std::placeholders::_1, std::placeholders::_3);
i.e. explicitly ignoring the second argument to the bind object. If bind enforced its argument count you would need an additional way to specify that e.g. a fourth argument was also to be ignored.
As for usefulness, consider binding a member signal handler to a signal:
sig.connect(std::bind(&C::on_sig, this, param, std::placeholders::_1));
If sig has extra unwanted emission parameters, then they are simply ignored by the bind object; otherwise, binding the same handler to multiple signals would require writing multiple forwarding wrappers for no real purpose.