Split write operations into a specified number of children operations

Not the prettiest bit of code but I need this for the Bulk API:
If a write operation is too large to send, I'll want to split it into multiple children operations to be sent individually instead.

Since it seems like this method is basically the same for deletes, inserts, and updates, why not factor out the base of it and put it in a common place, maybe in the write module or somewhere else that would make sense?

So, perhaps in your write module?
```
def split_ops(divisor, op_key)
   original_ops = @spec[op_key]
   quotient = original_ops / divisor

   [].tap do |children|
      divisor.times do |i|
         new_spec = @spec.dup
         new_spec[op_key] = original_ops.take(quotient)
         original_ops = original_ops.drop(quotient)
         # put remainder on the last op if not evenly divisible
         new_spec[op_key] += original_ops if !original_ops.empty? && (i == divisor - 1)
         children << self.class.new(new_spec)
      end
   end
end
```

And then each of these classes could simply call that function and pass in the proper key.  In this file, for example:
```
def split(divisor)
   split_opts(divisor, :deletes)
end
```