Update with arbitrary containers of Handles or HandleWrappers

[IamTheCarl]

The main purpose of this PR was to make it easier to check for duplicate handles referencing the same object, however it comes with a useful side effect.

I personally needed this because my CAD program accepts a scripting language to generate models with. The number of changes a user may make is dynamic, so I need the option to provide a variable number of new faces when updating a shell. I also need to validate that the new list of faces does not contain any duplicate handles so that I can avoid a panic and produce a more meaningful error message for the user.

The key change is that ObjectSet::new and ObjectSet::replace no longer take just arrays of Handles, but instead they take any iterable object that produces objects that can be turned into HandleWrapper.

This provides two key features:

1. You can pass an array of either Handle or HandleWrapper. Handle Wrapper makes it much easier to check if your handles are duplicates.
2. Any iterable object, such as a vector can be used for the update. I can only know how many shells my user will produce at runtime, so this is useful to me.

With such a workflow, things like this are now easy to implement:

    let mut result = Ok(());

    solid.update_shell(
        solid.shells().only(),
        |shell, core| {
           let new_faces: Vec<HandleWrapper<Face>> =
              vec![ /* The user does whatever they need to do to generate more faces */ ];
           
           // A HashSet is probably not an ideal way to search for duplicates on this small of a scale,
           // but it's good enough for this demo.
           let new_face_set = HashSet::from(new_faces.iter().map(|face_handle| face_handle.id()));
           
           if new_face_set.len() == new_faces.len() {
               new_faces // Nothing is wrong, we are clear to continue.
           } else {
               // This is an error situation.
               result = Err(Failure::DuplicateFaces);
               
               // Because there currently isn't a way to abort an update, we'll just return a copy of our
               // original shell this results in an unmodified solid.
               [shell.clone()]
           }
        },
        core,
    );

    return result;

I think at this point it might be good to rename HandleWrapper to ObjectReference to imply that we are comparing the references and not the objects, but I'll let you make that call. Coming up with a name that reflects the purpose of that thing is... difficult.

[hannobraun]

Thank you, @IamTheCarl! I left a few comments to complain about this or that, but overall it looks great. Merging.

[IamTheCarl]

I'll see about applying these comments tonight, but I'm glad you overall like it.