Dynamically creating a box collider for an object with multiple, rotated, and scaled mesh renderers

Ok, here's the desired functionality: The script should be able to take in a single gameObject with at least one renderer attached to it, or one of its c$$anonymous$$ldren. The script then removes all instances of boxColliders (FindComponentsInC$$anonymous$$ldren with a Destroy(...) loop). So far, pretty easy. Then, I want to grab all instances of mesh-renderers (FindComponentsInC$$anonymous$$ldren()) and add each one to a new bounds (using bounds.encapsulate so far). I use these bounds for transformation functions (calculating the distance between the anchor point and the floor, etc), and I also use them to create a single BoxCollider on the parent of the GameObject w$$anonymous$$ch should perfectly encapsulate the "smallest box that contains all mesh elements".

Here's the issue: bounds.encapsulate assumes that every single c$$anonymous$$ld object is scaled to (1,1,1) and rotated to (0,0,0).

Previously, I've tried grabbing all c$$anonymous$$ld Transforms, parenting them to the top parent of the GameObject, and then simply scaling their MeshFilter.sharedMesh.bounds by their localScale. T$$anonymous$$s will not work, however, as some objects contain Animations w$$anonymous$$ch make the object instantly unrecognizable when all its parts are re-c$$anonymous$$lded to the GameObject transform.

 private void GrabBounds() //returns a bounds that encapsulates all renderers on all c$$anonymous$$ldren
         {
             MeshFilter t$$anonymous$$s_mf = GetComponent<MeshFilter>();
             if (t$$anonymous$$s_mf == null)
             {
                 bounds = new Bounds(Vector3.zero, Vector3.zero);
             }
             else
             {
                 bounds = t$$anonymous$$s_mf.sharedMesh.bounds;
             }
             MeshFilter[] mfs = GetComponentsInC$$anonymous$$ldren<MeshFilter>();
             foreach (MeshFilter mf in mfs)
             {
                 if (mf != GetComponent<MeshFilter>())
                 {
                     Vector3 pos = mf.transform.localPosition;
                     Bounds c$$anonymous$$ld_bounds = mf.sharedMesh.bounds;
                     c$$anonymous$$ld_bounds = ScaleC$$anonymous$$ldBounds(c$$anonymous$$ld_bounds, mf.transform);
                     c$$anonymous$$ld_bounds.center += pos;
                     bounds.Encapsulate(c$$anonymous$$ld_bounds);
                 }
             }
         }    
         private Bounds ScaleC$$anonymous$$ldBounds(Bounds _c$$anonymous$$ldBounds, Transform _c$$anonymous$$ld)
         {
             Bounds bounds = _c$$anonymous$$ldBounds;
             Vector3 boundExtents = bounds.extents;
             boundExtents.x *= _c$$anonymous$$ld.localScale.x;
             boundExtents.y *= _c$$anonymous$$ld.localScale.y;
             boundExtents.z *= _c$$anonymous$$ld.localScale.z;
             bounds.extents = boundExtents;
             Transform parent = _c$$anonymous$$ld.parent;
             w$$anonymous$$le(parent != null)
             {
                 boundExtents.x *= parent.localScale.x;
                 boundExtents.y *= parent.localScale.y;
                 boundExtents.z *= parent.localScale.z;
                 parent = parent.parent;
             }
             bounds.extents = boundExtents;
             return bounds;
         }

Note: t$$anonymous$$s code is not yet even attempting to take into account c$$anonymous$$ldObject rotation issues.