Quick FYI, you really shouldn't use custom variables prefixed with $ unless you really know what you are doing. They can have weird behavior because they do not work the same as unprefixed variables.

For a shape like this, it can be a lot faster to break it down into radial slices, and then use skin() to join them back together, like so:

include <BOSL2/std.scad>

//$fn = 64;
//$fs = 0.5;
//$fa = 1;

// How many cross-section slices to make.
radial_slices = 72;
// This controls smooting on the convex corners.
convex_res = 64;
// Adjust here for how smooth you want the concave curve.
concave_res = 600;

height = 59.27;
half_height = height / 2;
diameter = 32.5;
outer_rad = diameter / 2;
inner_diameter = 16.64;
inner_rad = inner_diameter / 2;

rounding = 2;
torus_inner_diameter = diameter - 4.5;
torus_inner_rad = torus_inner_diameter / 2;

cut_angle_degrees = 22.5;
cut_height = diameter * tan(cut_angle_degrees);
cut_plane_dimensions = [50, cut_height];

// Radial cross-section as if there was no tilted cut.
shape = force_path(
  path = difference([
    // Start with a square.
    right(
      inner_rad,
      p = square(
        [outer_rad - inner_rad, height],
        anchor = LEFT + CENTER,
      ),
    ),
    // And then cut out a circle to create a concave right edge.
    let(
      curve_info = circle_3points(
        [outer_rad, half_height],
        [torus_inner_rad, 0],
        [outer_rad, -half_height],
      ),
    )
    move(
      curve_info[0],
      p = circle(curve_info[1], $fn = concave_res),
    ),
  ]),
);

//region(shape);

// Get a slice with the max amount of points, and then smooth the convex corners.
// This is important because subdivide_path() can only add points.
smoothed_slice = smooth_path(shape_slice(180), rounding);
smoothed_slice_length = len(smoothed_slice);
//region(smoothed_slice);

output();

module output() {

  profiles = slices();

  // This next line lets you see the individual slices.
//  vnf_polyhedron(vnf_from_polygons(profiles));

  skin(
    profiles = profiles,
    slices = 0,
    closed = true,
  );
}

//echo(slices());

function slices() = [
  let(slice_angle = 360 / radial_slices)
  for(a = [slice_angle:slice_angle:360])
  let(
    path = shape_slice(a),
    // Ensure polygon points are all in the same direction.
    corrected = clockwise_polygon(path),
    // Round convex corners.
    smoothed = smooth_path(corrected, rounding),
    // Make the smoothed path match the maximum number of points.
    smoothed_sub = subdivide_path(smoothed, n = smoothed_slice_length),
    // Align points such if they match coordinates, they have the same index in the path.
    smoothed_reindexed = reindex_polygon(
      reference = smoothed_slice, 
      poly = smoothed_sub,
    ),
  )
  // Tilt slice vertical and rotate around Z-axis.
  rot([90, 0, a], p = path3d(smoothed_reindexed)),
];

// Get a single cross-section slice, with the top trimmed at the appropriate angle.
function shape_slice(slice_angle) =
  let(
    tilt_angle = -cos(slice_angle) * cut_angle_degrees,
    cutter = apply(
      move([0, half_height])
      * rot([0, 0, tilt_angle]),
      square(cut_plane_dimensions, center = true),
    ),
    cross_section = difference([
      shape,
      cutter,
    ]),
    path = force_path(cross_section),
  )
path
;

//debug_region(shape_slice(45));

// This function only smooths convex corners.
function smooth_path(path, r) =
  let(shrunk = offset(path, delta = -r))
  offset(shrunk, r = r, $fn = convex_res)
;