Simplify python sequence marshaling

[pepone]

I think we can simplify the implementation of IcePy::SequenceInfo::marshal by computing the size of the optionals sequences, when we are about to marshal it and not up front.

We currently do it here:

ice/python/modules/IcePy/Types.cpp

Lines 1458 to 1505 in 8e3d0b0

	if (optional)
	{
	if (elementType->variableLength())
	{
	sizePos = os->startSize();
	}
	else if (elementType->wireSize() > 1)
	{
	//
	// Determine the sequence size.
	//
	Py_ssize_t sz = 0;
	if (p != Py_None)
	{
	Py_buffer pybuf;
	if (pi && PyObject_GetBuffer(p, &pybuf, PyBUF_SIMPLE | PyBUF_FORMAT) == 0)
	{
	// Strings are handled as variable length types above.
	assert(pi->kind != PrimitiveInfo::KindString);
	sz = pybuf.len;
	PyBuffer_Release(&pybuf);
	}
	else
	{
	PyErr_Clear(); // PyObject_GetBuffer sets an exception on failure.
	PyObjectHandle fs;
	if (pi)
	{
	fs = PyObjectHandle{getSequence(pi, p)};
	}
	else
	{
	fs = PyObjectHandle{PySequence_Fast(p, "expected a sequence value")};
	}
	if (!fs.get())
	{
	assert(PyErr_Occurred());
	return;
	}
	sz = PySequence_Fast_GET_SIZE(fs.get());
	}
	}
	const int32_t isz = static_cast<int32_t>(sz);
	os->writeSize(isz == 0 ? 1 : isz * elementType->wireSize() + (isz > 254 ? 5 : 1));
	}
	}

But seems it would be simpler to move this logic to:

ice/python/modules/IcePy/Types.cpp

Lines 1507 to 1544 in 8e3d0b0

	if (p == Py_None)
	{
	os->writeSize(0);
	}
	else if (pi)
	{
	marshalPrimitiveSequence(pi, p, os);
	}
	else
	{
	PyObjectHandle fastSeq{PySequence_Fast(p, "expected a sequence value")};
	if (!fastSeq.get())
	{
	return;
	}
	Py_ssize_t sz = PySequence_Fast_GET_SIZE(fastSeq.get());
	os->writeSize(static_cast<int>(sz));
	for (Py_ssize_t i = 0; i < sz; ++i)
	{
	PyObject* item = PySequence_Fast_GET_ITEM(fastSeq.get(), i);
	if (!item)
	{
	assert(PyErr_Occurred());
	throw AbortMarshaling();
	}
	if (!elementType->validate(item))
	{
	PyErr_Format(
	PyExc_ValueError,
	"invalid value for element %d of '%s'",
	static_cast<int>(i),
	const_cast<char*>(id.c_str()));
	throw AbortMarshaling();
	}
	elementType->marshal(item, os, objectMap, false);
	}
	}

This would avoid creating the sequence handlers twice.