make markdown rendering async

so we can do moar at render time

shared/src/advent/mod.rs

···
     }
 
     /// The text Markdown for challenge 1
-    fn markdown_text_part_one(
+    async fn markdown_text_part_one(
         &self,
         verification_code: Option<String>,
         additional_context: Option<&serde_json::Value>,
···
     }
 
     /// The text Markdown for challenge 2, could be None
-    fn markdown_text_part_two(
+    async fn markdown_text_part_two(
         &self,
         verification_code: Option<String>,
         additional_context: Option<&serde_json::Value>,

web/src/handlers/day.rs

···
     let part_one_text = match did_clone {
         None => challenge
             .markdown_text_part_one(None, None)
+            .await
             .map(|s| s.to_string())
             .unwrap_or_else(|_| "Error loading part one".to_string()),
         Some(ref users_did) => match challenge.get_days_challenge(&users_did).await {
···
                     let ctx = started.as_ref().and_then(|c| c.additional_context.as_ref());
                     challenge
                         .markdown_text_part_one(Some(new_code), ctx)
+                        .await
                         .map(|s| s.to_string())
                         .unwrap_or_else(|_| "Error loading part one".to_string())
                 }
···
                         let ctx = started.as_ref().and_then(|c| c.additional_context.as_ref());
                         challenge
                             .markdown_text_part_one(Some(new_code), ctx)
+                            .await
                             .map(|s| s.to_string())
                             .unwrap_or_else(|_| "Error loading part one".to_string())
                     }
···
                             Some(code),
                             current_challenge.additional_context.as_ref(),
                         )
+                        .await
                         .map(|s| s.to_string())
                         .unwrap_or_else(|_| "Error loading part one".to_string()),
                 },
···
     let part_two_text: Option<String> = match did_clone {
         None => challenge
             .markdown_text_part_two(None, None)
+            .await
             .map(|opt| opt.map(|s| s.to_string()))
             .unwrap_or(None),
         Some(users_did) => match challenge.get_days_challenge(&users_did).await {
···
                         let ctx = started.as_ref().and_then(|c| c.additional_context.as_ref());
                         challenge
                             .markdown_text_part_two(Some(new_code), ctx)
+                            .await
                             .map(|opt| opt.map(|s| s.to_string()))
                             .unwrap_or(None)
                     } else {
···
                                     started.as_ref().and_then(|c| c.additional_context.as_ref());
                                 challenge
                                     .markdown_text_part_two(Some(new_code), ctx)
+                                    .await
                                     .map(|opt| opt.map(|s| s.to_string()))
                                     .unwrap_or(None)
                             }
···
                                     Some(code),
                                     current_challenge.additional_context.as_ref(),
                                 )
+                                .await
                                 .map(|opt| opt.map(|s| s.to_string()))
                                 .unwrap_or(None),
                         }