This whole thread was of use to me. I wanted to add in my version as well. I included a bit of dedupe logic as well - specifically on the email. This also allows my data team to decide whether to create an opp or not depending on the Convert_No_Opp__c or Convert_with_Opp__c field.

Any feedback is appreciated. This class should be able to handle bulk updates, too.
 

public class leadConvert {
    public void convert(Lead[] givenLeads){
        System.debug('leadConvert.convert class running...................................................');
        
        List<Lead> noOppList = new List<Lead>();
        List<Lead> withOppList = new List<Lead>();
        Set<string> emailSet = new Set<string>();
        //set<string> phoneSet = new Set<string>();
        Set<string> accountSet = new Set<string>();
        
        //Loop through and grab information to query on
        for(lead l: givenLeads){
            if(!l.IsConverted){
                if(l.Convert_No_Opp__c){
                    noOppList.add(l);
                    if(l.Email!=null && l.Email!=''){emailSet.add(l.Email);}
                    //if(l.Phone!=null && l.Phone!=''){phoneSet.add(l.Phone);}
                    accountSet.add(l.Company);
                }
                else if(l.Convert_with_Opp__c){
                    withOppList.add(l);
                    if(l.Email!=null && l.Email!=''){emailSet.add(l.Email);}
                    //if(l.Phone!=null && l.Phone!=''){phoneSet.add(l.Phone);}
                    accountSet.add(l.Company);
                }
            }
        }
        
        System.debug('noOppList = ' + noOppList);
        System.debug('withOppList = ' + withOppList);
        
        //Query contacts to see if a contact exists that should be used as the target for conversion
        //We also have to get the account of that contact for the conversion
        List<Contact> emailMatchList = [SELECT id, lastname, email, accountid FROM Contact WHERE email IN :emailSet];
        //List<Contact> phoneMatchList = [SELECT id, lastname FROM Contact WHERE phone IN :phoneSet];        
        Map<string,id> emailMatchMap = new Map<string,id>();
        Map<id,id> contactAccountMap = new Map<id,id>();
        for(Contact c: emailMatchList){
            emailMatchMap.put(c.email, c.Id);
            contactAccountMap.put(c.id,c.AccountId);
        }
        
        //Search for accounts that match company
        List<Account> accountMatchList = [SELECT id, name FROM Account WHERE name IN :accountSet];
        Map<string,id> accountMatchMap = new Map<string,id>();
        for(Account a: accountMatchList){
            accountMatchMap.put(a.name, a.id);
        }
        
        //List used to convert
        List<Database.LeadConvert> leadConvertList = new List<Database.LeadConvert>();
        
        //Add to convert list without an opportunity
        for(lead lno: noOppList){
            Database.LeadConvert lc = new database.LeadConvert();
            lc.setLeadId(lno.Id);
            lc.convertedstatus = 'Closed - Converted';
            lc.setDoNotCreateOpportunity(true); //the only difference betweeen the two for loops
            if(lno.Email!=null && lno.Email!=''){
                if(emailMatchMap.containsKey(lno.Email) && emailMatchMap.get(lno.Email)!=null){
                    id contactID = emailMatchMap.get(lno.Email);
                    if(contactAccountMap.containsKey(contactID) && contactAccountMap.get(contactID)!=null){
                        lc.setAccountId(contactAccountMap.get(contactID));
                        lc.setContactId(contactID);
                    }
                }
            }
            if(lc.accountid == null){
                if(accountMatchMap.containsKey(lno.Company) && accountMatchMap.get(lno.Company)!=null){
                    lc.setAccountId(accountMatchMap.get(lno.Company));
                }
            }
            leadConvertList.add(lc);
        }
        
        //Add to convert list with an opportunity
        for(lead lyes: withOppList){
            Database.LeadConvert lc = new database.LeadConvert();
            lc.setLeadId(lyes.Id);
            lc.convertedstatus = 'Closed - Converted';
            lc.setDoNotCreateOpportunity(false); //the only difference betweeen the two for loops
            if(lyes.Email!=null && lyes.Email!=''){
                if(emailMatchMap.containsKey(lyes.Email) && emailMatchMap.get(lyes.Email)!=null){
                    id contactID = emailMatchMap.get(lyes.Email);
                    if(contactAccountMap.containsKey(contactID) && contactAccountMap.get(contactID)!=null){
                        lc.setAccountId(contactAccountMap.get(contactID));
                        lc.setContactId(contactID);
                    }
                }
            }
            if(lc.accountid == null){
                if(accountMatchMap.containsKey(lyes.Company) && accountMatchMap.get(lyes.Company)!=null){
                    lc.setAccountId(accountMatchMap.get(lyes.Company));
                }
            }
            leadConvertList.add(lc);
        }
        
        system.debug('leadConvertList = ' + leadConvertList);
        
        //update the leads
        //LeadConvert can only handle 100 records at a time
        if(!leadConvertList.isEmpty()){
            for(Integer i = 0; i <= leadConvertList.size()/100 ; i++){
                list<Database.LeadConvert> tempList = new list<Database.LeadConvert>();
                Integer startIndex = i*100;
                Integer endIndex = ((startIndex+100) < leadConvertList.size()) ? startIndex+100: leadConvertList.size();
                for(Integer j=startIndex;j<endIndex;j++){
                    tempList.add(leadConvertList[j]);
                }
                Database.LeadConvertResult[] lcrList = Database.convertLead(tempList, false);
                for(Database.LeadConvertResult lcr : lcrList)
                    System.assert(lcr.isSuccess());
            }
        }
    }
}

And here is the test class that is 90% coverage, but could easily be 100% coverage if needed.

@isTest
public class leadConvertTest {
    @isTest static void testConvert(){
        Test.startTest();
        Account a = new Account(name='leadConvertTestAccount');
        insert a;
        
        Contact c = new Contact(lastname = 'last', email='lno@leadConvertTest.com');
        insert c;
        
        lead lno = new Lead(lastName = 'lno last', Company = 'leadConvertTestAccount', LeadSource = 'Other', email='lno@leadConvertTest.com');
        insert lno;
        lead lno2 = new Lead(lastName = 'lno2 last', Company = 'leadConvertTestAccount', LeadSource = 'Other', email='lno2@leadConvertTest.com');
        insert lno2;
        
        lead lyes = new Lead(lastName = 'lyes last', Company = 'leadConvertTestAccount', LeadSource = 'Other', email='lyes@leadConvertTest.com');
        insert lyes;
        lead lyes2 = new Lead(lastName = 'lyes2 last', Company = 'leadConvertTestAccount', LeadSource = 'Other', email='lyes2@leadConvertTest.com');
        insert lyes2;
        
        List<Lead> leadList = [SELECT id, email, isconverted FROM Lead WHERE email LIKE '%leadConvertTest.com'];        
        System.debug('leadList = ' + leadList);
        
        for(Lead l: leadList){
            if(l.email == 'lno@leadConvertTest.com'){l.Convert_No_Opp__c = true;}
            if(l.email == 'lno2@leadConvertTest.com'){l.Convert_with_Opp__c = true;}
            if(l.email == 'lyes@leadConvertTest.com'){l.Convert_with_Opp__c = true;}
            if(l.email == 'lyes2@leadConvertTest.com'){l.Convert_No_Opp__c = true;}
        }
        update leadList;
        
        Test.stopTest();
        List<Account> acctCheck = [SELECT id, name FROM Account WHERE name = 'leadConvertTestAccount'];
        id acctCheckId = acctCheck[0].id;
        List<Contact> contactCheck = [SELECT id, lastname FROM Contact WHERE AccountId = :acctCheckId];
        List<Opportunity> oppCheck = [SELECT id FROM Opportunity WHERE AccountId = :acctCheckId];
        
        System.assertEquals(4, contactCheck.size(), 'There should be 4 contacts on the account, since one lead was converted into a contact');
        System.assertEquals(2, oppCheck.size(), 'There should be 2 Opps on the account');
    }
}