feat: Optimize avatar size multiplier for 2 << n px avatars

Instead of 2/3 which is not optimal for 512 px avatars usually passed to Core, use the sequence 3/4,
5/8, 4/8, 3/8... to reduce aliasing effects. Also divide the original avatar size, not the Core
constant (which is 512 px currently), this makes sense if e.g. 640 px avatars are passed.

Before, it was discussed that just 3/4 can be used. However:
- If we repeat the reduction step, we get `3 << n` as a numerator and this way accumulate aliasing
  effects. Better limit it to 5.
- If a 640 px avatar is passed, giving that `BALANCED_AVATAR_SIZE` is 512, 3/4 gives 384 i.e. 3/5 of
  640 which is good but still worse than 3/4.

Author: iequidoo

src/blob.rs

@@ -434,6 +434,7 @@ impl<'a> BlobObject<'a> {
                         });
 
             if do_scale {
+                let (mut m, mut d) = (3, 4);
                 loop {
                     if mem::take(&mut add_white_bg) {
                         self::add_white_bg(&mut img);
@@ -466,8 +467,17 @@ impl<'a> BlobObject<'a> {
                                 "Failed to scale image to below {max_bytes}B.",
                             ));
                         }
-
-                        target_wh = target_wh * 2 / 3;
+                        loop {
+                            let wh = max(img.width(), img.height()) * m / d;
+                            if wh < target_wh {
+                                target_wh = wh;
+                                break;
+                            }
+                            (m, d) = match m > 3 {
+                                true => (m - 1, d),
+                                false => (5, d * 2),
+                            };
+                        }
                     } else {
                         info!(
                             context,