gh-87613: Use Argument Clinic vectorcall for zip

zip had no vectorcall, so every call built an args tuple and a kwargs
dict, and strict=True also went through PyArg_ParseTupleAndKeywords with
a temporary empty tuple.  Argument error messages are unchanged except
for unknown keywords: `zip(strict=1, x=2)` now reports "got an
unexpected keyword argument 'x'" instead of "takes at most 1 keyword
argument (2 given)".  The docstring gains a summary line;
`__text_signature__` is unchanged.

pyperf microbenchmark (PGO+LTO, run serially):

| Benchmark              | base    | zip                   |
|------------------------|:-------:|:---------------------:|
| zip(a, b, strict=True) | 118 ns  | 61.5 ns: 1.92x faster |
| zip(a, b)              | 64.9 ns | 53.1 ns: 1.22x faster |
| zip(a)                 | 55.0 ns | 47.1 ns: 1.17x faster |
| list(zip(a, b))        | 123 ns  | 113 ns: 1.09x faster  |
| zip()                  | 27.4 ns | 25.7 ns: 1.07x faster |
| Sub(a, b)              | 71.5 ns | 70.6 ns: 1.01x faster |

Benchmark hidden because not significant (1): zip.`__new__`

Benchmark code:

```python
import pyperf

runner = pyperf.Runner()
setup = "a = (1, 2, 3); b = [4, 5, 6]"
for stmt in ["zip()", "zip(a)", "zip(a, b)", "zip(a, b, strict=True)",
             "list(zip(a, b))"]:
    runner.timeit(stmt, stmt, setup)
runner.timeit('zip.`__new__`', 'new(zip, a, b)', setup + '; new = zip.__new__')
runner.timeit('Sub(a, b)', 'S(a, b)', setup + '\nclass S(zip): pass')
```

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: cmaloney

Python/bltinmodule.c

@@ -3139,41 +3139,47 @@ typedef struct {
 
 #define _zipobject_CAST(op)     ((zipobject *)(op))
 
+/*[clinic input]
+class zip "zipobject *" "&PyZip_Type"
+@vectorcall
+@classmethod
+zip.__new__ as zip_new
+
+    *iterables: array
+    strict: bool = False
+
+Iterate over several iterables in parallel, yielding tuples.
+
+The zip object yields n-length tuples, where n is the number of
+iterables passed as positional arguments to zip().  The i-th element
+in every tuple comes from the i-th iterable argument to zip().  This
+continues until the shortest argument is exhausted.
+
+If strict is true and one of the arguments is exhausted before the
+others, raise a ValueError.
+
+   >>> list(zip('abcdefg', range(3), range(4)))
+   [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]
+[clinic start generated code]*/
+
 static PyObject *
-zip_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+zip_new_impl(PyTypeObject *type, PyObject * const *iterables,
+             Py_ssize_t iterables_length, int strict)
+/*[clinic end generated code: output=5e1a30829ce1f6ab input=4bd8e6a24e4bfb2e]*/
+
 {
     zipobject *lz;
     Py_ssize_t i;
     PyObject *ittuple;  /* tuple of iterators */
     PyObject *result;
-    Py_ssize_t tuplesize;
-    int strict = 0;
-
-    if (kwds) {
-        PyObject *empty = PyTuple_New(0);
-        if (empty == NULL) {
-            return NULL;
-        }
-        static char *kwlist[] = {"strict", NULL};
-        int parsed = PyArg_ParseTupleAndKeywords(
-                empty, kwds, "|$p:zip", kwlist, &strict);
-        Py_DECREF(empty);
-        if (!parsed) {
-            return NULL;
-        }
-    }
-
-    /* args must be a tuple */
-    assert(PyTuple_Check(args));
-    tuplesize = PyTuple_GET_SIZE(args);
+    Py_ssize_t tuplesize = iterables_length;
 
     /* obtain iterators */
     ittuple = PyTuple_New(tuplesize);
     if (ittuple == NULL)
         return NULL;
     for (i=0; i < tuplesize; ++i) {
-        PyObject *item = PyTuple_GET_ITEM(args, i);
-        PyObject *it = PyObject_GetIter(item);
+        PyObject *it = PyObject_GetIter(iterables[i]);
         if (it == NULL) {
             Py_DECREF(ittuple);
             return NULL;
@@ -3345,21 +3351,6 @@ static PyMethodDef zip_methods[] = {
     {NULL}  /* sentinel */
 };
 
-PyDoc_STRVAR(zip_doc,
-"zip(*iterables, strict=False)\n\
---\n\
-\n\
-The zip object yields n-length tuples, where n is the number of\n\
-iterables passed as positional arguments to zip().  The i-th element\n\
-in every tuple comes from the i-th iterable argument to zip().  This\n\
-continues until the shortest argument is exhausted.\n\
-\n\
-If strict is true and one of the arguments is exhausted before the\n\
-others, raise a ValueError.\n\
-\n\
-   >>> list(zip('abcdefg', range(3), range(4)))\n\
-   [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]");
-
 PyTypeObject PyZip_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
     "zip",                              /* tp_name */
@@ -3383,7 +3374,7 @@ PyTypeObject PyZip_Type = {
     0,                                  /* tp_as_buffer */
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
         Py_TPFLAGS_BASETYPE,            /* tp_flags */
-    zip_doc,                            /* tp_doc */
+    zip_new__doc__,                     /* tp_doc */
     zip_traverse,                       /* tp_traverse */
     0,                                  /* tp_clear */
     0,                                  /* tp_richcompare */
@@ -3402,6 +3393,7 @@ PyTypeObject PyZip_Type = {
     PyType_GenericAlloc,                /* tp_alloc */
     zip_new,                            /* tp_new */
     PyObject_GC_Del,                    /* tp_free */
+    .tp_vectorcall = zip_vectorcall,
 };